a
    ûbeø ã                   @   sN  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Zd dlm	Z	 ddl
mZ ddl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 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* ej+d  dkrVe,Z-ne,e.fZ-dd„ Z/dd„ Z0dúdd„Z1dd„ Z2G dd„ de3ƒZ4G d d!„ d!e3ƒZ5d"d#„ Z6e6G d$d%„ d%eƒƒZ7G d&d'„ d'e7ƒZ8G d(d)„ d)eƒZ9G d*d+„ d+e7ƒZ:G d,d-„ d-e7ƒZ;G d.d/„ d/e;ƒZ<G d0d1„ d1e7ƒZ=G d2d3„ d3e=ƒZ>G d4d5„ d5e=ƒZ?G d6d7„ d7e=ƒZ@G d8d9„ d9e=ƒZAG d:d;„ d;e=ƒZBG d<d=„ d=e=ƒZCG d>d?„ d?e7ƒZDG d@dA„ dAe7ƒZEG dBdC„ dCe7ƒZFG dDdE„ dEeEƒZGG dFdG„ dGeEƒZHG dHdI„ dIeEƒZIG dJdK„ dKeEƒZJG dLdM„ dMeEƒZKG dNdO„ dOeEƒZLG dPdQ„ dQeEƒZMG dRdS„ dSeEƒZNG dTdU„ dUe;ƒZOG dVdW„ dWe;ƒZPG dXdY„ dYePe9ƒZQG dZd[„ d[e;ƒZRG d\d]„ d]e;ƒZSG d^d_„ d_e;ƒZTG d`da„ dae;e9ƒZUG dbdc„ dceUƒZVG ddde„ dee7ƒZWG dfdg„ dge7ƒZXG dhdi„ dieUƒZYG djdk„ dkeUƒZZG dldm„ dmeYƒZ[G dndo„ doe[ƒZ\G dpdq„ dqe\ƒZ]G drds„ dse\ƒZ^G dtdu„ dueYƒZ_G dvdw„ dwe;ƒZ`G dxdy„ dye;e9ƒZaG dzd{„ d{eaƒZbG d|d}„ d}eaƒZcG d~d„ de;ƒZdG d€d„ de;ƒZeG d‚dƒ„ dƒe;ƒZfG d„d…„ d…e;ƒZgG d†d‡„ d‡e;ƒZhG dˆd‰„ d‰ehƒZiG dŠd‹„ d‹ehƒZjG dŒd„ dehƒZkG dŽd„ dehƒZlG dd‘„ d‘e;ƒZmG d’d“„ d“e;ƒZnG d”d•„ d•e;ƒZoG d–d—„ d—e;ƒZpG d˜d™„ d™e:ƒZqG dšd›„ d›e;ƒZrG dœd„ de;ƒZsG dždŸ„ dŸe;ƒZtG d d¡„ d¡e;ƒZuG d¢d£„ d£e;ƒZvG d¤d¥„ d¥e;ƒZwG d¦d§„ d§e;ƒZxG d¨d©„ d©e7ƒZyG dªd«„ d«e;ƒZzG d¬d­„ d­e;ƒZ{G d®d¯„ d¯eƒZ|G d°d±„ d±e|e;ƒZ}G d²d³„ d³e7ƒZ~G d´dµ„ dµe7ƒZd¶d·„ Z€G d¸d¹„ d¹e|e;ƒZG 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ÃehƒZ†G dÄdÅ„ dÅe;ƒZ‡G dÆdÇ„ dÇe7ƒ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ŒƒZdÒdÓ„ ZŽdÔdÕ„ dÖdÕ„ eŽd×œZdØdÙdÚœZG dÛdÜ„ dÜe;ƒZ‘G dÝdÞ„ dÞe;ƒZ’G dßdà„ dàe;ƒZ“G dádâ„ dâe7ƒ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;ƒZ˜e#j™rÖdëZšndìZše ›dídî¡Zœe ›dïdî¡Ze ›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)r	   )r
   )Ú	TypeSlots)r   r   )r   r   r   r   r   r   ÚTemplateScope)r   ©r   )ÚFuture)ÚOptions)Ú
DebugFlags)Úhas_np_pythranÚpythran_typeÚis_pythran_bufferé   )Úadd_metaclassé   c                 C   s   | d   ¡ | d fS ©Nr   r   )Zget_filenametable_entry©Úpos© r)   úe/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/Cython/Compiler/Nodes.pyÚrelative_position)   s    r+   c                 C   s‚   t js
|S dt| ƒ }|d u r&t|ƒS |j}|d urZz| |¡ W n tyX   d }Y n0 |sht|ƒ}nt|d | ƒ}||_|S )NzFile: %s (starting at line %s)Ú
)r   Zembed_pos_in_docstringr+   r   ÚencodingÚencodeÚUnicodeEncodeError)r(   Ú	docstringZpos_liner-   Údocr)   r)   r*   Úembed_position-   s     

r2   c                 C   sv  d }d}d }}| j rxt| jdƒ | jD ]:\}}|js8q(|jdv rPd}|sb|} q(|jdv r(d}|} q(|rx|rxt| jdƒ |  |¡}	| jrô| jsô| j	dv rô|d urÊ|	d urÊ|	j
sÊ| |¡}
|
rÊ|
j
rÊd}d }	|	tjtjtjfv rò| j	dkrîtjnt}	n|	d ur| jrt| jd	ƒ |	d urN|r<|s<|	j
s<t| jd
ƒ t| j|	dd}n |rbt| jdƒ nt| jdƒ ||	fS )NFzSDicts should no longer be used as type annotations. Use 'cython.int' etc. directly.)Útypes   typeT)Úctypes   ctypez9Duplicate type declarations found in signature annotation)ÚintÚlongÚfloatr7   zWStrings should no longer be used for type declarations. Use 'cython.int' etc. directly.zOPython type declaration in signature annotation does not refer to a Python type)r3   Úis_argz'Ambiguous types in annotation, ignoringz0Unknown type declaration in annotation, ignoring)Úis_dict_literalr   r(   Úkey_value_pairsZis_string_literalÚvalueÚanalyse_as_typeÚis_nameZcython_attributeÚnameÚis_pyobjectZ
infer_typer
   Úc_long_typeÚ
c_int_typeÚc_float_typeZc_double_typer   ÚCAnalysedBaseTypeNode)Ú
annotationÚenvÚassigned_valueÚ	base_typeZis_ambiguousZexplicit_pytypeZexplicit_ctyper>   r;   Úarg_typeZassigned_typer)   r)   r*   Úanalyse_type_annotationG   sX    ÿ




ÿ
ÿÿrI   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j ¡ }| jd7  _ˆ| i |¤Ž}| jd8  _||jj ¡ kr¼|jj 
|¡ n| ddd¡}| 	|¡ |S ˆ| i |¤ŽS d S )Nr   r#   z(                    /* %s -> %s.%s %s */ú é   z->z<-)ÚlenÚ
isinstanceZ
call_levelÚ	__class__Ú__name__r(   ÚbufferÚstreamÚtellÚputlnÚtruncateÚreplace)ÚargsÚkwdsÚnodeÚcodeÚmarkerZpristineÚstartÚres©Úcodewriter_classÚfuncr)   r*   Úfw   s(    ü

zwrite_func_call.<locals>.fr)   )r_   r^   r`   r)   r]   r*   Úwrite_func_callv   s    ra   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)Útypesrd   ÚCodere   ÚdictÚitemsrM   ra   Úsuperrb   Ú__new__)Úclsr>   ÚbasesÚattrsrd   re   ÚmnameÚm©rN   r)   r*   rk   –   s    
zVerboseCodeWriter.__new__)rO   Ú
__module__Ú__qualname__rk   Ú__classcell__r)   r)   rq   r*   rb   “   s   rb   c                       s,   e Zd ZdZeg d¢ƒZ‡ fdd„Z‡  ZS )ÚCheckAnalyserszCMetaclass to check that type analysis functions return a node.
    )Úanalyse_typesÚanalyse_expressionsÚanalyse_target_typesc                    sf   ddl m} dd„ }t|ƒ}| ¡ D ]*\}}t||ƒr$|| jv r$|||ƒ||< q$tt| ƒ | |||¡S )Nr   rc   c                    s   ‡ ‡fdd„}|S )Nc                     s,   ˆ | i |¤Ž}|d u r(t dˆ| |f ƒ |S )Nz%s %s %s)Úprint)rV   ÚkwargsÚretval©r_   r>   r)   r*   Úcallª   s    z3CheckAnalysers.__new__.<locals>.check.<locals>.callr)   )r>   r_   r}   r)   r|   r*   Úcheck©   s    z%CheckAnalysers.__new__.<locals>.check)	rf   rd   rh   ri   rM   Úmethodsrj   ru   rk   )rl   r>   rm   rn   rd   r~   ro   rp   rq   r)   r*   rk   §   s    zCheckAnalysers.__new__)rO   rr   rs   Ú__doc__Úsetr   rk   rt   r)   r)   rq   r*   ru       s   ru   c                 C   s   t jrttƒ| ƒS | S ©N)r   Zdebug_trace_code_generationr$   rb   )rl   r)   r)   r*   Ú_with_metaclass¸   s    rƒ   c                   @   s®   e Zd ZdZdZdZdZdZdZdZ	dZ
dZdZdZd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 r‚   )r(   Ú__dict__Úupdate)Úselfr(   Úkwr)   r)   r*   Ú__init__Ý   s    zNode.__init__Z	Operationc                 C   s   t | jd| j ƒ d S )Nz%s not allowed without gil)r   r(   Úgil_message©r‡   rE   r)   r)   r*   Ú	gil_erroræ   s    zNode.gil_errorc                 C   s   |  ¡ s|  ¡  d S r‚   )Zis_cppÚ	cpp_errorr‹   r)   r)   r*   Ú	cpp_checkë   s    zNode.cpp_checkc                 C   s   t | jd| j ƒ d S )Nz%s only allowed in c++)r   r(   Úcpp_message©r‡   r)   r)   r*   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 r)   r)   )Ú.0Úxr)   r)   r*   Ú
<listcomp>ü   ó    z#Node.clone_node.<locals>.<listcomp>)r   Úchild_attrsÚgetattrrM   ÚlistÚsetattr)r‡   ÚresultÚattrnamer;   r)   r)   r*   Ú
clone_nodeò   s    



zNode.clone_nodec                 C   s   d S r‚   r)   r‹   r)   r)   r*   Úanalyse_declarations  s    zNode.analyse_declarationsc                 C   s   t d| jj ƒ‚d S )Nz*analyse_expressions not implemented for %s©r   rN   rO   r‹   r)   r)   r*   rw     s    ÿzNode.analyse_expressionsc                 C   s   t d| jj ƒ‚d S )Nz$generate_code not implemented for %sr   ©r‡   rY   r)   r)   r*   Úgenerate_code  s    ÿzNode.generate_codec                 C   s   t | tƒr| j |¡ d S r‚   )rM   Ú	BlockNodeÚbodyÚannotaterž   r)   r)   r*   r¢   "  s    
zNode.annotatec              	   C   s–   z| j W S  ty   | j}| js0|| _ | Y S | jD ]J}t| |ƒ}|d u rNq6t|tƒrr|D ]}t|| ¡ ƒ}q\q6t|| ¡ ƒ}q6|| _ | Y S 0 d S r‚   )	Z_end_posÚAttributeErrorr(   r•   r–   rM   r—   ÚmaxÚend_pos)r‡   r(   ÚattrÚchildÚcr)   r)   r*   r¥   '  s"    


zNode.end_posr'   éd   c           
   	      sì   ˆ dkrdS ˆdu rt ƒ ‰t| ƒˆv r:d| jjt| ƒf S ˆ t| ƒ¡ ‡ ‡‡‡fdd„‰‡fdd„| j ¡ D ƒ}t|ƒdk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 r)   r)   )r‘   Úitem)Ú
dump_childÚlevelr)   r*   r“   K  r”   z1Node.dump.<locals>.dump_child.<locals>.<listcomp>)rM   r„   Údumpr—   ÚjoinÚrepr)r’   r­   ©Úcutoffr¬   ÚencounteredÚ
filter_out)r­   r*   r¬   G  s
    

zNode.dump.<locals>.dump_childc                    s    g | ]\}}|ˆ vr||f‘qS r)   r)   )r‘   Úkeyr;   )r´   r)   r*   r“   O  r”   zNode.dump.<locals>.<listcomp>z<%s (0x%x)>z  z<%s (0x%x)
z%s  %s: %s
r   z%s>)r   ÚidrN   rO   Úaddr…   ri   rL   )
r‡   r­   r´   r²   r³   rn   Úindentr\   rµ   r;   r)   r±   r*   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)r-   Zerror_handlingr   r%   éÿÿÿÿNz             # <<<<<<<<<<<<<<
r#   z"%s":%d:%d
%s
)r(   Ú	get_linesr¤   ÚrstripZget_escaped_descriptionr¯   )	r‡   Zmark_columnrZ   Zsource_descÚlineÚcolÚcontentsÚlinesÚcurrentr)   r)   r*   Údump_posZ  s    ÿzNode.dump_pos)N)r   r'   r©   N)Fr¹   )rO   rr   rs   r=   Úis_noneZis_nonecheckÚ
is_literalÚis_terminatorÚ
is_wrapperÚtempsr•   Úouter_attrsZcf_stateZcoercion_typer‰   rŠ   Únogil_checkÚin_nogil_contextrŒ   r   rŽ   r   r›   rœ   rw   rŸ   r¢   r¥   r®   rÅ   r)   r)   r)   r*   r„   ¿   s6   
%
r„   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 r‚   )Ú
directivesr¡   rœ   ©r‡   rE   Úoldr)   r)   r*   rœ   t  s    z+CompilerDirectivesNode.analyse_declarationsc                 C   s&   |j }| j |_ | j |¡| _||_ | S r‚   )rÏ   r¡   rw   rÐ   r)   r)   r*   rw   z  s
    z*CompilerDirectivesNode.analyse_expressionsc                 C   s8   |j }|jj }| j |j_ | j ||¡ ||_ ||j_ d S r‚   )rÏ   Úglobalstater¡   Úgenerate_function_definitions)r‡   rE   rY   Zenv_oldZcode_oldr)   r)   r*   rÓ     s    
z4CompilerDirectivesNode.generate_function_definitionsc                 C   s*   |j j}| j|j _| j |¡ ||j _d S r‚   )rÒ   rÏ   r¡   Úgenerate_execution_code©r‡   rY   rÑ   r)   r)   r*   rÔ   ‰  s    
z.CompilerDirectivesNode.generate_execution_codec                 C   s*   |j j}| j|j _| j |¡ ||j _d S r‚   )rÒ   rÏ   r¡   r¢   rÕ   r)   r)   r*   r¢     s    
zCompilerDirectivesNode.annotateN)
rO   rr   rs   r€   r•   rœ   rw   rÓ   rÔ   r¢   r)   r)   r)   r*   rÎ   k  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 r‚   )Úglobal_scopeZundeclared_cached_builtinsrÒ   Zadd_cached_builtin_decl)r‡   rE   rY   ÚentriesÚentryr)   r)   r*   Úgenerate_cached_builtins_decls˜  s    
z(BlockNode.generate_cached_builtins_declsc                 C   s   |j D ]}| ||¡ qd S r‚   )Zlambda_defsrÓ   )r‡   rE   rY   rX   r)   r)   r*   Úgenerate_lambda_definitionsž  s    
z%BlockNode.generate_lambda_definitionsN)rO   rr   rs   rÙ   rÚ   r)   r)   r)   r*   r    •  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                 O   s   t | g|¢R i |¤Ž}|S r‚   )rÛ   )r(   rE   rV   rˆ   rX   r)   r)   r*   Úcreate_analysed§  s    zStatListNode.create_analysedc                 C   s   | j D ]}| |¡ qd S r‚   ©rÜ   rœ   ©r‡   rE   Ústatr)   r)   r*   rœ   ¬  s    
z!StatListNode.analyse_declarationsc                    s   ‡ fdd„| j D ƒ| _ | S )Nc                    s   g | ]}|  ˆ ¡‘qS r)   ©rw   ©r‘   rà   ©rE   r)   r*   r“   ³  s   ÿz4StatListNode.analyse_expressions.<locals>.<listcomp>©rÜ   r‹   r)   rã   r*   rw   ±  s    
ÿz StatListNode.analyse_expressionsc                 C   s   | j D ]}| ||¡ qd S r‚   ©rÜ   rÓ   ©r‡   rE   rY   rà   r)   r)   r*   rÓ   ·  s    
z*StatListNode.generate_function_definitionsc                 C   s&   | j D ]}| |j¡ | |¡ qd S r‚   )rÜ   Úmark_posr(   rÔ   ©r‡   rY   rà   r)   r)   r*   rÔ   ¼  s    
z$StatListNode.generate_execution_codec                 C   s   | j D ]}| |¡ qd S r‚   ©rÜ   r¢   rè   r)   r)   r*   r¢   Â  s    
zStatListNode.annotateN)rO   rr   rs   r•   ÚstaticmethodrÝ   rœ   rw   rÓ   rÔ   r¢   r)   r)   r)   r*   rÛ   ¢  s   
rÛ   c                   @   s   e Zd Zdd„ Zdd„ ZdS )ÚStatNodec                 C   s   d S r‚   r)   ©r‡   rE   rY   r)   r)   r*   rÓ   Ô  s    z&StatNode.generate_function_definitionsc                 C   s   t d| jj ƒ‚d S )Nz.generate_execution_code not implemented for %sr   rž   r)   r)   r*   rÔ   ×  s    ÿz StatNode.generate_execution_codeN)rO   rr   rs   rÓ   rÔ   r)   r)   r)   r*   rë   Ç  s   rë   c                   @   s2   e Zd Zdg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 r‚   )rM   ÚCVarDefNode)r‘   rX   r)   r)   r*   Ú	<genexpr>ò  r”   z6CDefExternNode.analyse_declarations.<locals>.<genexpr>)	Úin_cincluder¡   rœ   Zinclude_fileZverbatim_includerÜ   rÏ   ÚallÚadd_include_file)r‡   rE   Zold_cinclude_flagrÜ   Zlater)   r)   r*   rœ   ã  s    
z#CDefExternNode.analyse_declarationsc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw   õ  s    z"CDefExternNode.analyse_expressionsc                 C   s   d S r‚   r)   rž   r)   r)   r*   rÔ   ø  s    z&CDefExternNode.generate_execution_codec                 C   s   | j  |¡ d S r‚   ©r¡   r¢   rž   r)   r)   r*   r¢   û  s    zCDefExternNode.annotateN)rO   rr   rs   r•   rœ   rw   rÔ   r¢   r)   r)   r)   r*   rí   Ü  s
   rí   c                   @   s   e Zd Zg ZdZdd„ ZdS )ÚCDeclaratorNoderº   c                 C   s   d S r‚   r)   r   r)   r)   r*   Úanalyse_templates  s    z!CDeclaratorNode.analyse_templatesN)rO   rr   rs   r•   Úcalling_conventionrõ   r)   r)   r)   r*   rô   ÿ  s   rô   c                   @   s    e Zd ZdgZdZddd„ZdS )ÚCNameDeclaratorNodeÚdefaultNr   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	rp|j
rp| |j
¡}|| _| |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>   Úis_ptrÚis_arrayÚ	is_bufferr   r(   Úis_voidÚdeclaration_coder   Úis_fusedÚfused_to_specificÚ
specializer3   )r‡   rG   rE   ÚnonemptyÚ
visibilityÚin_pxdr)   r)   r*   Úanalyse  s    zCNameDeclaratorNode.analyse)r   NF)rO   rr   rs   r•   rø   r  r)   r)   r)   r*   r÷     s   r÷   c                   @   s$   e Zd ZdgZdd„ Zd	dd„ZdS )
ÚCPtrDeclaratorNodeÚbasec                 C   s
   | j  ¡ S r‚   ©r  rõ   r   r)   r)   r*   rõ   5  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  )r?   r   r(   r
   Ú
c_ptr_typer  r  )r‡   rG   rE   r  r  r  Zptr_typer)   r)   r*   r  8  s    
zCPtrDeclaratorNode.analyse)r   NF©rO   rr   rs   r•   rõ   r  r)   r)   r)   r*   r  0  s   r  c                   @   s$   e Zd ZdgZdd„ Zd	dd„ZdS )
ÚCReferenceDeclaratorNoder  c                 C   s
   | j  ¡ S r‚   r	  r   r)   r)   r*   rõ   D  s    z*CReferenceDeclaratorNode.analyse_templatesr   NFc                 C   s2   |j rt| jdƒ t |¡}| jj|||||dS )Nz-Reference base type cannot be a Python objectr
  )r?   r   r(   r
   Z
c_ref_typer  r  )r‡   rG   rE   r  r  r  Zref_typer)   r)   r*   r  G  s    
z CReferenceDeclaratorNode.analyse)r   NFr  r)   r)   r)   r*   r  ?  s   r  c                   @   s   e Zd ZddgZddd„ZdS )	ÚCArrayDeclaratorNoder  Ú	dimensionr   NFc                    sd  |j r| ¡ s|jrœddlm} t| j|ƒr6| jj}n| jf}‡ fdd„|D ƒ}d |v rx| d ¡}	t	||	 j
dƒ t}n| | j
|¡}| jj|ˆ |||dS | jrü| j ˆ ¡| _| jjjsÈt	| jj
dƒ | j ¡ }
|
d urúzt|
ƒ}
W n tyø   Y n0 nd }
| ¡ st	| j
d| ƒ |jr.t	| j
d	ƒ |jrBt	| j
d
ƒ t ||
¡}| jj|ˆ |||dS )Nr   ©Ú	TupleNodec                    s   g | ]}|  ˆ ¡‘qS r)   )r<   )r‘   Úvrã   r)   r*   r“   [  r”   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Ú	ExprNodesr  rM   r  rV   Úindexr   r(   r   Úspecialize_herer  r  Úanalyse_const_expressionr3   Úis_intÚget_constant_c_result_coder5   Ú
ValueErrorÚis_completer?   r
   Zc_array_type)r‡   rG   rE   r  r  r  r  rV   ÚvaluesÚixÚsizeZ
array_typer)   rã   r*   r  T  s>    




zCArrayDeclaratorNode.analyse)r   NF©rO   rr   rs   r•   r  r)   r)   r)   r*   r  N  s   r  c                   @   s@   e Zd Zg d¢ZdZdZdZdZdd„ Zddd„Z	dd	d
„Z
dS )ÚCFuncDeclaratorNode)r  rV   Úexception_valuer   Nc                 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)rM   r  r  r  r  r$  r  rV   r   r(   Ú	templatesÚappendr
   ÚTemplatePlaceholderTyper>   )r‡   r  r$  Útemplate_nodeZtemplate_nodesÚtemplater)   r)   r*   rõ   Œ  s"    



z%CFuncDeclaratorNode.analyse_templatesFc                    sÞ  |d u ri }|r|d8 }g }t ˆjƒD ].\}}	|	jˆ ||dkoNˆ joNdˆ jvd\}
}|
j}||v rÂ|| }| ˆ ¡}|d u rŽt|jdƒ n4|t	j
u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¡ |jrÈˆjs¬ˆjrÈˆjdkrÈtˆjdƒ nHˆjd u r,ˆjr,ˆjdkr,|jd ur,|dkr,|s,ˆ js,ddlm} |ˆj|j|dˆ_ˆjr
ˆj ˆ ¡ˆ_ˆjdkr°ˆ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}nZˆj %|ˆ ¡ ˆ ¡ˆ_ˆj &¡ }|d u rìt'dˆjj(j) ƒ‚| *ˆjj¡s
tˆjjdƒ ˆj}|j!r$tˆjdƒ t	j+||ˆj,ˆj||ˆjj-ˆj.ˆj/ˆj0ˆj1ˆj2d}ˆjrŠ|j3r~‡ ‡fdd„}||_4nˆ 5|ˆ ¡ ˆ jd }|rÊ|j-}|rÄ||krÄtˆjd||f ƒ ||_-ˆ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typeinfozAException clause not allowed for function returning Python objectÚextern©Ú	ConstNode©r;   r3   Ú*zSException value must be a Python exception or cdef function with no arguments or *.z1get_constant_c_result_code not implemented for %sz6Exception value incompatible with function return typez!Function cannot return a function)	Úoptional_arg_countr#  Úexception_checkrö   ÚnogilÚwith_gilÚis_overridableÚis_const_methodr%  c                    s   ˆ  | ˆ |¡ d S r‚   )Údeclare_optional_arg_struct)Ú	func_typeÚfused_cname©rE   r‡   r)   r*   Údeclare_opt_arg_struct
  s    z;CFuncDeclaratorNode.analyse.<locals>.declare_opt_arg_structÚcallspecz2cannot have both '%s' and '%s' calling conventions©r  r  )6Ú	enumeraterV   r  Úis_c_class_scoperÏ   r>   r<   r   r(   r
   r   Úsame_asr  ÚcnameÚis_unspecifiedÚparent_typerü   r  rG   rþ   r&  ÚCFuncTypeArgrø   r6  r7  rò   r?   r#  r  r3  r  r3   Úis_errorr  Úreturn_typeÚc_char_typer;   Ú	coerce_tor  r   rN   rO   Úassignable_fromÚ	CFuncTypeÚhas_varargsrö   r8  r9  Úoverridabler;  r%  r   r@  r<  )r‡   rK  rE   r  Údirective_localsr  r  Zfunc_type_argsÚiZarg_nodeÚname_declaratorr3   r>   Ú	type_nodeÚ
other_typeÚexc_valÚ	exc_checkr3  Zexc_val_typer=  r@  rA  rÄ   r)   r?  r*   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u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_flagr(   rF  r   )r   r	   Úpyrex_prefixÚdeclare_varr
   rA   r(   rV   rL   r6  r>   r3   ÚmangleZopt_arg_prefixr  Zget_fused_cnamerÖ   Údeclare_struct_or_unionÚdefined_in_pxdÚusedr  Úop_arg_struct)	r‡   r=  rE   r>  r[  Zarg_count_memberÚargZstruct_cnameZop_args_structr)   r)   r*   r<    s&    
úz/CFuncDeclaratorNode.declare_optional_arg_struct)r   NNF)N)rO   rr   rs   r•   rQ  r6  r;  r%  rõ   r  r<  r)   r)   r)   r*   r"  z  s   
xr"  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 )Nú)Const base type cannot be a Python objectr
  )r?   r   r(   r
   Úc_const_typer  r  )r‡   rG   rE   r  r  r  Úconstr)   r)   r*   r  @  s    ÿ
zCConstDeclaratorNode.analyse)r   NFr!  r)   r)   r)   r*   re  ;  s   re  c                   @   st   e Zd Zg d¢ZddgZdZdZdZdZdZ	dZ
dZdZdZdZdZddd	„Zd
d„ Zdd„ Zdd„ Zddd„ZdS )ÚCArgDeclNode)rG   Ú
declaratorrø   rD   rø   rD   r   r   NFc           
      C   st  |rd | j _| _| jd u rdt| jtƒr†| jjdkr†|r€| j jr\| j j|dd}| 	¡ }n| j j}t
|ƒ| j_d | j _d| j _d}nd}d| j _| j j||d}t| j dƒrÂ| j jrÂ| j j| j_|jrt| j tƒrt| jtƒr| j}t|jtƒr|j}qì| j j|_|j }| jrR|rR|jd rR| j jd u rR|  |¡}	|	d urR|	}| jj|||dS | j| jfS d S )NTrº   )Úcould_be_nameFÚarg_nameÚannotation_typing©r  )rG   r+  r3   rM   rj  r÷   r>   Úis_basic_c_typer  Úempty_declaration_coder   r8   Úhasattrrl  rü   ÚTemplatedTypeNoder  r  Úarray_declaratorrD   rÏ   Úinject_type_from_annotationsrT  )
r‡   rE   r  r+  r3   rl  rk  rG   rj  rH   r)   r)   r*   r  g  sD    

ÿ
þ
(

zCArgDeclNode.analysec                 C   s4   | j }|sd S t||| jd\}}|d ur0|| _|S )N)rF   )rD   rI   rø   rG   )r‡   rE   rD   rG   rH   r)   r)   r*   rt  •  s    z)CArgDeclNode.inject_type_from_annotationsc                 C   sJ   | j d u rD| jrD| jjr6| j |¡ | j | j ¡ ¡S | | j¡| _ | j S r‚   )Údefault_valuerø   rÇ   Úgenerate_evaluation_coder3   Ú	cast_coder™   Zget_argument_default_constrž   r)   r)   r*   Úcalculate_default_value_codež  s    
z)CArgDeclNode.calculate_default_value_codec                 C   s   | j r| j  |¡ d S r‚   )rø   r¢   rž   r)   r)   r*   r¢   ¨  s    zCArgDeclNode.annotatec                 C   s–   | j }|d u s|jrd S |d u r*|  |¡}| |¡ | |¡ |rJ| ¡ n
| | j¡}| d||f ¡ | jj	r~| 
| ¡ ¡ | |¡ | |¡ d S ©Nú%s = %s;)rø   rÇ   rx  rv  Úmake_owned_referencer™   Ú	result_asr3   rS   r?   Úput_giverefÚgenerate_post_assignment_codeÚ
free_temps)r‡   rY   ÚtargetÚoverloaded_assignmentrø   r™   r)   r)   r*   Úgenerate_assignment_code¬  s    



z%CArgDeclNode.generate_assignment_code)r   F)NF)rO   rr   rs   r•   rË   r+  Úis_type_argÚ
is_genericÚkw_onlyÚnot_noneÚor_noner3   rT  ru  rD   Ú
is_dynamicr  rt  rx  r¢   r‚  r)   r)   r)   r*   ri  H  s$   
.	
ri  c                   @   s   e Zd Zdd„ ZdS )ÚCBaseTypeNodec                 C   s
   |   |¡S r‚   ©r  r‹   r)   r)   r*   r<   Ä  s    zCBaseTypeNode.analyse_as_typeN)rO   rr   rs   r<   r)   r)   r)   r*   r‰  ¼  s   r‰  c                   @   s   e Zd Zg Zddd„ZdS )rC   Fc                 C   s   | j S r‚   ©r3   )r‡   rE   rk  r)   r)   r*   r  Í  s    zCAnalysedBaseTypeNode.analyseN)Fr!  r)   r)   r)   r*   rC   È  s   rC   c                   @   s*   e Zd Zg ZdZg ZdZdZddd„ZdS )ÚCSimpleBaseTypeNodeNFc                 C   s  d }| j r2t | j| j| j¡}|s.t| jdƒ n>| jdkrJ| jsJt	}n&| jd u rp| j
rh|jrh|j}nt	}n | jrÊ|}| jD ].}| |¡}|d ur¦|jr¦|jj}q€d } q°q€|d u rÎ| | j| j¡}n|}|rp|jrâ| ¡ }| | j¡}|d urønx|r(| j
r|jr|j}nt	}t| jƒ| _nH| jr^| j| jvrPt| 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!u rîtj"}| |¡ d| _|rø|S tj#S d S )Nz&Unrecognised type modifier combinationÚobjectz'%s' is not a type identifierz#can only complexify c numeric typesT)$ro  r
   Zsimple_c_typeÚsignedZlongnessr>   r   r(   Úmodule_pathr   r+  rD  rH  Úlookupr  r3   r[  Úfind_imported_modulerÖ   Zlookup_typer   rl  r%  r'  r   r  r  ÚcomplexÚ
is_numericÚ
is_complexZCComplexTypeZcreate_declaration_utility_coder   Zcomplex_typeZc_double_complex_typer   )r‡   rE   rk  r3   r[  r«   rØ   r)   r)   r*   r  á  sh    





zCSimpleBaseTypeNode.analyse)F)	rO   rr   rs   r•   rl  r  ro  r’  r  r)   r)   r)   r*   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 nB tyv } z*t|j	|j
ƒ t ¡ | _| jW  Y d }~S d }~0 0 | | j|¡sŽt| _n&t ||¡| _| j | j¡ |  |¡ | jS ©Nr   ©Ú
MemoryView)r—  r  rJ  rº   r›  Zget_axes_specsr˜  r   r   ÚpositionZmessage_onlyr
   Z	ErrorTyper3   Zvalidate_axesr(   r   ZMemoryViewSliceTypeZvalidate_memslice_dtypeÚuse_memview_utilities)r‡   rE   rk  rG   r›  Z
axes_specsÚer)   r)   r*   r  4  s    


zMemoryViewSliceTypeNode.analysec                 C   s   ddl m} | |j¡ d S r™  )rº   r›  Úuse_utility_codeÚview_utility_code)r‡   rE   r›  r)   r)   r*   r  K  s    z-MemoryViewSliceTypeNode.use_memview_utilitiesN)F)rO   rr   rs   r>   r•   r  r  r)   r)   r)   r*   r•  /  s   
r•  c                   @   s   e Zd ZdgZddd„ZdS )ÚCNestedBaseTypeNoderG   Nc                 C   sr   | j  |¡}|tju 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)rG   r  r
   r   r  r   r(   r[  Úlookup_herer>   Úis_typer3   )r‡   rE   rk  rG   Ú
type_entryr)   r)   r*   r  X  s    

zCNestedBaseTypeNode.analyse)Nr!  r)   r)   r)   r*   r¡  P  s   r¡  c                   @   s&   e Zd Zg d¢ZdZdZddd„ZdS )rr  )r—  Úpositional_argsÚkeyword_argsÚ
dtype_nodeNFc                 C   sÚ  |d u r| j  |¡}|jr|S |jr | ¡ r | jrP| jjrPt| jdƒ t	j
| _nLg }| jD ]0}| |¡}|d u r€t|jdƒ t
}| |¡ qZ| | j|¡| _n|jr4ddlm} | | j|| j| j|j¡}tjd dk ròtdd„ | ¡ D ƒƒ}t	j|fi |¤Ž| _t|ƒr²t| jƒr²t	 t| jƒ| j¡| _n~t| jd	d d
}	t| jƒdks^| jjrtt| jdƒ t	j
| _n>| js‚d }
n
| jd }
t | j|	|
d| _!| j! ||¡d | _| jj"rÔ|j#rÔ| j $|j#¡| _| jS )Nz+c++ templates cannot take keyword argumentsz!unknown type in template argumentr   ©ÚBufferr   r%   c                 S   s   g | ]\}}|  d ¡|f‘qS )r»   )r.   )r‘   r>   r;   r)   r)   r*   r“   —  s   ÿz-TemplatedTypeNode.analyse.<locals>.<listcomp>rº   ©r>   rF  zinvalid array declaration)r  r  )%r—  r  rJ  r  r  r¦  r:   r   r(   r
   r   r3   r¥  r<   r&  r  r?   rº   r©  Úanalyse_buffer_optionsÚbuffer_defaultsr   Úversion_inforh   ri   Z
BufferTyper    r"   ZPythranExprr!   r÷   rL   r  rs  r   r  r  )r‡   rE   rk  rG   Útemplate_typesr(  r3   r©  ÚoptionsZempty_declaratorr  r)   r)   r*   r  v  s^    



ûÿ

ýzTemplatedTypeNode.analyse)FN)rO   rr   rs   r•   r§  r>   r  r)   r)   r)   r*   rr  f  s   	rr  c                   @   s   e Zd ZddgZddd„ZdS )ÚCComplexBaseTypeNoderG   rj  Fc                 C   s$   | j  ||¡}| j ||¡\}}|S r‚   )rG   r  rj  )r‡   rE   rk  r  Ú_r3   r)   r)   r*   r  ½  s    zCComplexBaseTypeNode.analyseN)Fr!  r)   r)   r)   r*   r°  ·  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   r(   r   r&  Zdeclare_tuple_typerb  r3   )r‡   rE   rk  Zcomponent_typesr¨   r3   rØ   r)   r)   r*   r  È  s    

zCTupleBaseTypeNode.analyseN)Fr!  r)   r)   r)   r*   r²  Ã  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>   r(   rð   )r‡   rE   r3   rØ   r)   r)   r*   rœ   á  s    
z"FusedTypeNode.analyse_declarationsFc                 C   s\   g }| j D ]@}| |¡}|s*t|jdƒ q
||v r@t|jdƒ q
| |¡ q
tj|| jdS )Nr,  zType specified multiple times©r>   )rf   r<   r   r(   r&  r
   Ú	FusedTyper>   )r‡   rE   rk  rf   rU  r3   r)   r)   r*   r  è  s    

zFusedTypeNode.analyseN)F)rO   rr   rs   r€   r•   rœ   r  r)   r)   r)   r*   r´  Õ  s   	r´  c                   @   s   e Zd ZdgZddd„ZdS )ÚCConstTypeNoderG   Fc                 C   s*   | j  ||¡}|jr t| jdƒ t |¡S )Nrf  )rG   r  r?   r   r(   r
   rg  )r‡   rE   rk  r  r)   r)   r*   r    s    ÿzCConstTypeNode.analyseN)Fr!  r)   r)   r)   r*   r¸  ü  s   r¸  c                   @   s&   e Zd ZddgZdZdZddd„ZdS )rî   rG   ÚdeclaratorsNc                 C   s  | j d u ri | _ |s|}|| _| jr4| jd  ¡ }nd }|d u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 |¡}|jrÚ| jsÚ|jsÊ|jrÚt| jdƒ tS d | _| j}| jD ]"}t| jƒdkr(t|tƒs(|j
d r(t|jd	dƒ | jo@| jdko@|j}|rNd
|_t|tƒrx|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r.| jdkr.t|jdƒ |
j r¬d|j
v rHd|
_!|j"||
|j|| j| j| j#| j$| jd	| _| jd urŽt% %| j ¡| j_ |r| jj& '|¡ d| j_(qì| jrÂt| jddƒ | j rÖt| jdƒ |j)||
|j||| j| j#dd| _t*j+rìt,| j| j-ƒ| j_-qìd S )Nr   r1  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)rR  r  r  rB  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 insteadrê   T)rF  r  r  ÚapiÚ	modifiersrQ  zfcpdef variables will not be supported in Cython 3; currently they are no different from cdef variablesr#   z,Decorators can only be followed by functions)rF  r  r  rº  Úis_cdef).rR  Ú
dest_scoper¹  rõ   r  r   r(   rL   r   Úouter_scoperÏ   Zdeclare_typer>   rG   r  r   r  rD  Úis_module_scoper   rØ   rM   r÷   r   rQ  r"  r  rü   Úis_memoryviewslicer?   rF  Zis_referencer  Úis_static_methodÚdeclare_cfunctionrº  r»  r   r3   Úcreate_to_py_utility_codeÚcreate_wrapperr^  r   Ú
docstringsr2   r1   )r‡   rE   r½  r%  Ztemplate_paramrG   r  rj  Zcreate_extern_wrapperrT  r3   r>   rF  r)   r)   r*   rœ     s°    



ÿÿþýÿþÿ
ÿ



ý
ÿýz CVarDefNode.analyse_declarations)N)rO   rr   rs   r•   Ú
decoratorsrR  rœ   r)   r)   r)   r*   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)
r`  r>   rZ  r\  r(   rF  r  rº  rÉ  rØ   ©r‡   rE   r[  r)   r)   r*   Údeclare„  s
    ýzCStructOrUnionDefNode.declarec                 C   s    d }| j d urt| jƒ}|  ||¡ | j d u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   r1  z)Struct cannot contain itself as a member.)rÈ  r   r>   rË  r  rð   rØ   ra  rœ   r  Úvar_entriesr3   rü   rG   r   r(   )r‡   rE   r[  r¦   r3   r)   r)   r*   rœ   Š  s     





z*CStructOrUnionDefNode.analyse_declarationsc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw   œ  s    z)CStructOrUnionDefNode.analyse_expressionsc                 C   s   d S r‚   r)   rž   r)   r)   r*   rÔ   Ÿ  s    z-CStructOrUnionDefNode.generate_execution_code)N©rO   rr   rs   r•   rË  rœ   rw   rÔ   r)   r)   r)   r*   rÇ  v  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 u 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 r)   ©r
   r'  ©r‘   Útemplate_nameÚrequiredr)   r)   r*   r“   µ  s   ÿz(CppClassNode.declare.<locals>.<listcomp>c                 s   s   | ]\}}| V  qd S r‚   r)   ©r‘   r±  rÒ  r)   r)   r*   rï   ·  r”   z'CppClassNode.declare.<locals>.<genexpr>c                 s   s   | ]\}}|V  qd S r‚   r)   rÓ  r)   r)   r*   rï   ¸  r”   zGRequired template parameters must precede optional template parameters.)Úbase_classesr  r%  )
r%  Úsumrñ   r   r(   Údeclare_cpp_classr>   rF  r  rØ   )r‡   rE   r®  Znum_optional_templatesr)   r)   r*   rË  ±  s    
ÿ"þzCppClassNode.declarec           
   	      sx  ˆj d u rd  }}n dd„ ˆj D ƒ}dd„ ˆj D ƒ}d ‰ˆjd urRtˆjˆ |d‰‡fdd„}t|‡ ‡fdd„ˆjD ƒƒ}ˆ jˆjˆˆjˆj|ˆj	|dˆ_
ˆj
d u rªd S d	ˆj
_ˆd urÄˆj
jˆ_g }‡fd
d„‰ˆjd ur^ˆjrôˆ jsôd	ˆj
_ˆjD ]*}t|dd ƒ}|r| ˆ¡ | ˆ¡ qúˆˆjƒD ],}	| |	¡ ˆj d ur0dd |¡ |	_q0tˆj|dˆ_ˆˆ_d S )Nc                 S   s   g | ]\}}|‘qS r)   r)   )r‘   rÑ  r±  r)   r)   r*   r“   Â  r”   z5CppClassNode.analyse_declarations.<locals>.<listcomp>c                 S   s   g | ]\}}t  || ¡‘qS r)   rÏ  rÐ  r)   r)   r*   r“   Ã  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   r(   )Z
base_classr   r)   r*   Úbase_okÈ  s    z2CppClassNode.analyse_declarations.<locals>.base_okc                    s   g | ]}|  ˆpˆ ¡‘qS r)   rŠ  )r‘   Úb)rE   r[  r)   r*   r“   Í  r”   )r  r%  r   c                 3   sB   | D ]8}t |tƒr|V  qt |tƒrˆ |jjƒD ]
}|V  q0qd S r‚   )rM   ÚCFuncDefNoderÎ   r¡   rÜ   )rÈ  r¦   Zsub_attr)Úfunc_attributesr)   r*   rÛ  ×  s    

z:CppClassNode.analyse_declarations.<locals>.func_attributesrË  ztemplate <typename %s>z, typename rä   )r%  rÈ  r   r>   ÚfilterrÔ  rÖ  r(   rF  r  rØ   r  r3   r  rð   ra  r–   rË  rœ   r&  r¯   Útemplate_declarationrÛ   r¡   r[  )
r‡   rE   r®  Ztemplate_namesrØ  Zbase_class_typesZdefined_funcsr¦   rË  r_   r)   )rE   rÛ  r[  r‡   r*   rœ   ¾  sH    

ÿ

þ




z!CppClassNode.analyse_declarationsc                 C   s   | j  | jjj¡| _ | S r‚   )r¡   rw   rØ   r3   r[  r‹   r)   r)   r*   rw   í  s    z CppClassNode.analyse_expressionsc                 C   s   | j  | jjj|¡ d S r‚   )r¡   rÓ   rØ   r3   r[  rì   r)   r)   r*   rÓ   ñ  s    z*CppClassNode.generate_function_definitionsc                 C   s   | j  |¡ d S r‚   ©r¡   rÔ   rž   r)   r)   r*   rÔ   ô  s    z$CppClassNode.generate_execution_codec                 C   s   | j  |¡ d S r‚   ró   rž   r)   r)   r*   r¢   ÷  s    zCppClassNode.annotate)
rO   rr   rs   rÆ  rË  rœ   rw   rÓ   rÔ   r¢   r)   r)   r)   r*   rÎ  £  s   /rÎ  c                   @   s2   e Zd ZdgZdd„ Zdd„ Zdd„ Zdd	„ Zd
S )ÚCEnumDefNoderi   c              	   C   s,   |j | j| j| j| j| j| j| jd| _d S )N)rF  r\  r  rº  rÄ  )	Zdeclare_enumr>   r(   rF  r\  r  rº  rÄ  rØ   r‹   r)   r)   r*   rË    s    üzCEnumDefNode.declarec                 C   s<   | j d ur8| jr|jsd| j_| j D ]}| || j¡ q$d S ©Nr   )ri   r  rð   rØ   ra  rœ   )r‡   rE   r«   r)   r)   r*   rœ     s
    

z!CEnumDefNode.analyse_declarationsc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw     s    z CEnumDefNode.analyse_expressionsc              
   C   s¦   | j dks| jr¢| | j¡ |jjtjdd}| jj	D ]^}| 
d||j| ||j¡f ¡ | |¡ | 
dtj|j|| |j¡f ¡ | |tj¡ q6|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(   Ú	funcstateÚallocate_tempr
   r   rØ   Úenum_valuesrS   rF  Úerror_goto_if_nullÚ
put_gotrefr	   Zmoddict_cnamer>   Ú
error_gotoÚput_decref_clearÚrelease_temp)r‡   rY   Útempr«   r)   r)   r*   rÔ     s$    ý

üz$CEnumDefNode.generate_execution_codeNrÍ  r)   r)   r)   r*   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|j| j | j	| j
|j|j|jol|jd u d}|j |¡ |jr”|jj |j¡ d S )N)rF  r  rº  rÄ  )r;   r  r3   r  rM  r
   rA   Zdeclare_constr>   r(   rF  r  rº  rÄ  rå  r&  r  )r‡   rE   Z
enum_entryrØ   r)   r)   r*   rœ   3  s    
üz%CEnumDefItemNode.analyse_declarationsN)rO   rr   rs   r•   rœ   r)   r)   r)   r*   rì  ,  s   rì  c                   @   s,   e Zd ZddgZdd„ Zdd„ Zdd„ Zd	S )
ÚCTypeDefNoderG   rj  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 )NrB  )rF  r  rº  Tr   )rG   r  rj  r  r  r>   rF  rµ  r(   rº  r   rð   ra  )r‡   rE   r  rT  r3   r>   rF  rØ   r)   r)   r*   rœ   L  s    ÿ

þz!CTypeDefNode.analyse_declarationsc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw   ]  s    z CTypeDefNode.analyse_expressionsc                 C   s   d S r‚   r)   rž   r)   r)   r*   rÔ   `  s    z$CTypeDefNode.generate_execution_codeN©rO   rr   rs   r•   rœ   rw   rÔ   r)   r)   r)   r*   rí  C  s   rí  c                   @   sØ   e 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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   sv   d}| j D ]f}|jrTd}|jr@|j |¡|_|j |j|¡|_qpt|jdƒ d |_q
|jr`d}q
|r
t|jdƒ q
d S )Nr   r   z)This argument cannot have a default valuez/Non-default argument following default argument)	rV   rø   r„  rv   rM  r3   r   r(   r…  )r‡   rE   Zdefault_seenrd  r)   r)   r*   Úanalyse_default_values‡  s    
z"FuncDefNode.analyse_default_valuesc                 C   s2   |d u rd S |j d r$| |¡d u r.| |¡}|S )Nrm  )rÏ   r<   rv   )r‡   rE   rD   r)   r)   r*   Úanalyse_annotation—  s
    
zFuncDefNode.analyse_annotationc                 C   s&   | j D ]}|jr|  ||j¡|_qd S r‚   )rV   rD   rñ  ©r‡   rE   rd  r)   r)   r*   Úanalyse_annotationsŸ  s    
zFuncDefNode.analyse_annotationsc                 C   s¶   | j }|j}|j|v r,||j }| |¡}n<t|tƒrd|jrd|jd rd|j}| |¡}|d u rh|S n|S |d u r~t	|j
dƒ n4|tur¬| |¡s¬t	|jj
dƒ t	|j
dƒ n||_|S )Nrm  r,  r-  r.  )rR  r3   r>   r<   rM   ri  rD   rÏ   rt  r   r(   r   rE  rG   )r‡   rE   rd  rR  Ú	orig_typerU  rV  r)   r)   r*   Úalign_argument_type¤  s$    


zFuncDefNode.align_argument_typec                 C   s   dS ©Nr   r)   ©r‡   Úlenvr)   r)   r*   Úneed_gil_acquisition»  s    z FuncDefNode.need_gil_acquisitionc                 C   s‚   |}|j s|jr|j}q| jr8t| jj||| jjd}nt| jj||d}| j	|_	| jj
}|jrp|jol|j |_|| _|j|_|S )N)r>   r¾  Úparent_scopeZ
scope_name)r>   r¾  rú  )Úis_py_class_scoperD  r¾  Úneeds_closurer   rØ   r>   rF  r   rK  r3   r  r8  r9  Úlocal_scoperÏ   )r‡   rE   Úgenvrø  r3   r)   r)   r*   Úcreate_local_scope¾  s(    ýþzFuncDefNode.create_local_scopec                 C   s   | j  |¡ d S r‚   rÞ  rì   r)   r)   r*   Úgenerate_function_bodyÓ  s    z"FuncDefNode.generate_function_bodyc           '      C   sÂ  ddl m} | jjr ddl m} | j}|jrD|jsDdtj	tj
f }ntj
}| |¡ | j ||¡ |  ||¡ | jjdko‚| jjj}| jjdko˜| jjj}|p |}	|	r¾d| jvr¾| jdg | _|  ¡ }
|jjd }|jjd	 }|sæ|rú|j t d
d¡¡ | |¡ | ¡ |_|j |j_|  | j!¡ |  "||¡ | #d¡ |
rL| #|
¡ |  $||¡p^| j%}| j&rz| 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¡ |  0||¡ |j1D ] }|j2s2|j3s2| 4|¡ q2d}| jj5s¢| jj6rrd}n| jjr†d|j7 }| #d| j .tj8¡|f ¡ | 9¡ }|  :|¡ | j;}| j*pÆ| j/}|j<D ]}|j-j6rÎd} qêqÎdd„ |j=D ƒ}|jo|j>o|p|}|jo(|j>o(| }|j p8|j>}|sF|rX| ?¡  d|j_n|jrp|j>rp| @¡  |s||r®| jAs®| B¡  | jCr | jC D|¡nd }| E|¡ |r¾|  F|¡ |rÞ| G¡  |jH| jj|d |rî|  I|¡ | j*r¾tJ Kdd¡}tJ L|j,j-j|¡}|s(d|j,j-jM }| #dtj	|j,j- N¡ ||j,j-jMtjOf ¡ | #dtj	 ¡ | #dtj	|j,j- Pd¡f ¡ | QdtR¡ | #| S| j!¡¡ | #d¡ | Ttj	¡ | #d¡ | j/rL| jUrî| #d ||j,j- N¡ tjVf ¡ n| #d!||j,j- N¡ tjVf ¡ |jr*| #dtj	|f ¡ n"| j*rL| Q||j,j-¡ | W|¡ |sX|rž| jAs–| jXrv| jjd" }n| jj}|jY|| j!|jj d# d|j_Z|  [||¡ t\| t]ƒ}|j<D ]n}|j-j6rò|sÞt^|j_ƒdkr&|j2s&| `|¡ n4|rº|j-jrºt^|j_ƒdkrº|ja|jb|jjd$ qº|j1D ]D}|j3r0t^|j_ƒdkr0|j2s0|jcrh| d|¡ n
| `|¡ q0|j1|j< D ](}|j-jer‚|jfjgjhr‚| i||¡ q‚|  j|¡ |j<D ] }|j-jer¼| k||| j!¡ q¼|rô| l¡  d%|j_|  m||¡ |j | j!d%d& | #d¡ | #d'¡ | jjnsŒ| jj6rNtj8}| o|| j¡ n>| jjp}|rr| #dtj8|f ¡ n| jj5sŒ| #d(tj8 ¡ |jq|jrv 	r | jjns°| s|jt¡ | u|jq¡ |j v¡ D ]\} }!|jw| |!|j d$ qÆt^|ƒd)k}"|"rN|j tx¡ | #d*¡ | #d+¡ | #d,¡ | #d-¡ |D ]}| y||¡ q0| #d.¡ | jjrn| ztj8|¡ tj8}#n|  {¡ }#|  |¡ }$|#d usŽ|$râ|jr°|j>s°| #d/¡ | ?¡  | }| jj~¡ |j	r|j>	s| l¡  | #d¡ n*t| jj!d0| jj~ d)ƒ | €| jj~|j¡ | jjp}%|#d u 	r(|%	r(|%}#|#d u	rT|#tj8k	rn| #dtj8|#f ¡ n| jj5	sn| #d(tj8 ¡ |	r~|  |¡ |"	s”|	s”| jj	r | s|j¡ | u|jt¡ |D ]}| y||¡ 	q°|	rÔ|  ‚|¡ | jj
r4| ƒ| j „tj8¡¡}&| #d1|& ¡ |j
r| ?¡  | #d2¡ |j
r*| l¡  | #d¡ | u|j¡ |j1D ]z}|jh
rF|j2
r^
qF|j-j
r~|j…|jb|j d$ n@|j-j6
rF|j3
r t^|j_ƒdk
rF|jc
r´| †|¡ n
| ‡|¡ 
qF|j<D ]n}|j-j6r |
sìt^|j_ƒdkr4|j2s4| ‡|¡ n4|j-j
rÈ|r t^|j_ƒdk
rÈ|j…|jb|j d$ 
qÈ| j*rR| ˆtj	|j,j-¡ |jsœ| jjp}%|  {¡ }#|#d u r~|%r~|%}#| jj6rœ| ‰| j Štj8¡¡ | jj‹rÊ| jjd3krÊ| #d4tj8tj8f ¡ |sÖ|rd%|j_Z| jAs| jj6r|jŒtj8|jj d# n|jŒd|jj d# |js,| ¡  |sB|jrR|j>rR| l¡  d%|j_| jj5sl| #d5tj8 ¡ | #d¡ |
rŠ| #d6|
 ¡ | Ž|j¡ | ¡  | j&r´| j& ||¡ |  |¡ d S )7Nr   r¨  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 r)   )rb  )r‘   rØ   r)   r)   r*   r“   =  r”   z=FuncDefNode.generate_function_definitions.<locals>.<listcomp>)Úacquire_gilZtp_newrk   z
%s->tp_newz%s = (%s)%s(%s, %s, NULL);úif (unlikely(!%s)) {rz  ÚPy_Noneú} else {Ú}z*%s = (%s) __Pyx_CyFunction_GetClosure(%s);z%s = (%s) %s;z
 (wrapper)©r8  ©Úhave_gilF©Útraceú/* function exit code */z!__Pyx_pretend_to_initialize(&%s);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);}Ú{z&Unraisable exception in function '%s'.ú	if (%s) {zOPyErr_SetString(PyExc_TypeError, "Memoryview return value is not initialized");Ú__hash__z5if (unlikely(%s == -1) && !PyErr_Occurred()) %s = -2;ú
return %s;ú#endif /*!(%s)*/)‘rº   r©  rK  rÀ  r›  rý  Úis_closure_scopeZis_passthroughr	   Úcur_scope_cnameÚouter_scope_cnameZmangle_closure_cnamesr¡   rÓ   rÚ   rØ   r>   r[  rD  r»  Úget_preprocessor_guardrÒ   rÏ   rŸ  r   Úload_cachedÚenter_cfunc_scopeÚ	new_labelÚreturn_from_error_cleanup_labelr8  rã  Ú	gil_ownedrç   r(   rÙ   rS   Úneeds_assignment_synthesisÚpymethdef_requiredÚpy_funcÚgenerate_function_headerrû  r¾  rü  ÚputÚscope_classr3   rÿ   Úneeds_outer_scopeÚgenerate_argument_declarationsrÌ  Ú
in_closurer8   Úput_var_declarationrþ   r?   Zmemslice_entry_initÚretval_cnameÚinsertion_pointÚgenerate_keyword_listr  Úarg_entriesZbuffer_entriesÚhas_with_gil_blockÚput_ensure_gilÚdeclare_gilstateÚis_generatorÚput_trace_declarationsÚcode_objectÚcalculate_result_codeÚput_trace_frame_initÚgetbuffer_checkÚput_declare_refcount_contextÚput_setup_refcount_contextÚgetbuffer_initr   ZConstructorSlotZget_slot_functionÚtypeptr_cnamerp  Úempty_tuplerw  Ú
put_increfr   rè  rç  Úis_cyfunctionÚ
self_cnamer}  rÉ   Úput_trace_callÚ	can_traceÚgenerate_argument_parsing_coderM   rÚ  rL   Úcf_assignmentsÚput_var_increfÚput_incref_memoryviewslicerF  Úxdecref_cleanupÚput_var_xincrefrý   Z
buffer_auxZbuflocal_nd_varrb  Zput_init_varsÚgenerate_argument_type_testsZput_acquire_arg_bufferÚput_release_ensured_gilr   rÈ   Úput_init_to_py_noneru  Úerror_labelÚlabels_usedÚput_gotoÚreturn_labelÚ	put_labelÚall_managed_tempsÚput_xdecrefÚrestore_exception_utility_codeZput_release_buffer_codeZput_init_entryÚerror_valueÚcaller_will_check_exceptionsÚput_add_tracebackÚqualified_namer   Zput_unraisableÚgetbuffer_error_cleanupÚgetbuffer_normal_cleanupÚunlikelyZerror_conditionÚput_xdecref_memoryviewsliceZput_var_xdecrefÚput_var_decrefÚ
put_decrefÚput_xgiverefÚas_pyobjectÚ
is_specialÚput_trace_returnÚput_finish_refcount_contextÚput_temp_declarationsÚexit_cfunc_scopeÚgenerate_wrapper_functions)'r‡   rE   rY   r©  r›  rø  r  Zis_getbuffer_slotZis_releasebuffer_slotZis_buffer_slotÚpreprocessor_guardr  r  r  ÚcenvrØ   ÚinitÚtempvardecl_coder  Zhave_object_argsrd  Zused_buffer_entriesZacquire_gil_for_var_decls_onlyZacquire_gil_for_refnanny_onlyZuse_refnannyr9  Ztp_slotZslot_func_cnameZ
trace_namer¼  ÚlhsÚvalrF  r3   Zbuffers_presentÚerr_valrX  Zdefault_retvalÚcondr)   r)   r*   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)
r3   rþ   r   r(   r  rü   rÀ  Zdeclare_argr>   rD   )r‡   rE   rd  rØ   r)   r)   r*   Ú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)z:if (unlikely(!__Pyx_ArgTypeTest(%s, %s, %d, "%s", %s))) %szICannot test type of extern C class without type object name specification)r3   Ztypeobj_is_availablerÒ   rŸ  r   r!  r@  rØ   rF  rS   Úaccept_noner>   Úis_builtin_typeZrequire_exactrè  r(   r   )r‡   rd  rY   r@  Úarg_coder)   r)   r*   Ú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)) {zMPyErr_Format(PyExc_TypeError, "Argument '%%.%ds' must not be None", "%s"); %séÈ   r  )
r3   rÀ  rØ   rF  rS   r¤   rL   r>   rè  r(   )r‡   rd  rY   rF  r)   r)   r*   Úgenerate_arg_none_checkŸ  s    
þz#FuncDefNode.generate_arg_none_checkc                 C   s   d S r‚   r)   rž   r)   r)   r*   ri  ¬  s    z&FuncDefNode.generate_wrapper_functionsc                 C   s,   |  | j¡ | jD ]}|js| |¡ qd S r‚   )rç   r(   rV   rˆ  r‚  ©r‡   rY   rd  r)   r)   r*   rÔ   ¯  s    
z#FuncDefNode.generate_execution_codec              	   C   sF   | j jd }z|jjjjd j}W n ttfy<   d }Y n0 ||fS )Nr   Úobj)rý  r3  r3   rG   r[  r×   r£   ÚKeyError)r‡   Ú	py_bufferÚobj_typer)   r)   r*   Ú_get_py_buffer_info¹  s    
zFuncDefNode._get_py_buffer_infoc                 C   sB   |   ¡ \}}|j}| d| ¡ | d¡ | d¡ | d¡ d S )Nzif (%s == NULL) {zZPyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");z
return -1;r  )r€  rF  rS   )r‡   rY   r~  r±  Úviewr)   r)   r*   r<  É  s    

zFuncDefNode.getbuffer_checkc                 C   sN   |   ¡ \}}|j}|r<|jr<| d| |¡ | d| ¡ n| d| ¡ d S )Nú%s->objz%s->obj = NULL;)r€  rF  r?   rO  r}  rS   ©r‡   rY   r~  r  r  r)   r)   r*   r?  Ò  s    
zFuncDefNode.getbuffer_initc                 C   sf   |   ¡ \}}|j}|rT|jrT| d| ¡ | d| ¡ | d| |¡ | d¡ n| d| ¡ d S )Nzif (%s->obj != NULL) {r‚  r  zPy_CLEAR(%s->obj);©r€  rF  r?   rS   rç  ré  rƒ  r)   r)   r*   r\  Û  s    
z#FuncDefNode.getbuffer_error_cleanupc                 C   sV   |   ¡ \}}|j}|rR|jrR| d| ¡ | d| ¡ | d| |¡ | d¡ d S )Nzif (%s->obj == Py_None) {r‚  r  r„  rƒ  r)   r)   r*   r]  æ  s    
z$FuncDefNode.getbuffer_normal_cleanupc                 C   s`   | j jsd S | j j}tj |¡}|s(d S |dkrB| j j d¡sBd S |dv rX| j jjrXd S | 	¡ S )NZ__long__Ú__int__©r  r  )
rØ   rd  r>   r   Úmethod_name_to_slotÚgetr[  r¢  rD  Úpreprocessor_guard_code)r‡   r>   Úslotr)   r)   r*   r   ï  s    z"FuncDefNode.get_preprocessor_guard)#rO   rr   rs   r(  rü  r,  r'  r7  Úis_generator_bodyZis_async_defr»  Úhas_fused_argumentsÚstar_argÚstarstar_argrC  r9  rð  rñ  ró  rõ  rù  rÿ  r   rÓ   rr  rx  rz  ri  rÔ   r€  r<  r?  r\  r]  r   r)   r)   r)   r*   rï  d  sF      0

			rï  c                       sî   e Zd Zg 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dd	„ Zd
d„ Zdd„ Zd0dd„Zdd„ Zdd„ Zdd„ Zdd„ Zd1dd„Zd2dd„Zdd„ Zd d!„ Zd"d#„ Zd$d%„ Zd&d'„ Z‡ fd(d)„Zd*d+„ Zd,d-„ Z d.d/„ Z!‡  Z"S )3rÚ  )rG   rj  r¡   Úpy_func_statFNc                 C   s   | j jS r‚   )rØ   r>   r   r)   r)   r*   Úunqualified_name 	  s    zCFuncDefNode.unqualified_namec                 C   s   | j r| j jS d S r‚   )r(  r9  r   r)   r)   r*   r9  #	  s    zCFuncDefNode.code_objectc                 C   sJ  |j | _| jd u ri | _| j |j di ¡¡ | jd urb| j |¡}|d u rnt| jj	dƒ t
j}n| j |¡}d|jv o‚| d¡ | _t| jtƒr¼| jj||d| jd u | j| jd\}}n$| jj||d| jd u | 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€t | jj	dƒ t!| j|jƒD ]º\}}|  "||¡ |j|_|j#|_#|j$|_$|  %|j|j	|¡ |jj&rÜd| _'|jj(r d| j)v r t |j	ddƒ |jj(s|jj*rŽ| jj+r,t|j	dƒ nd| j)v rŽt |j	ddƒ qŽ|  %|j,| j	|¡ |j#}	|j$}
| j-|_-| j|_|j.|	|| j	|
| j| j| jd u| j)| jd	| _/| j0| j/_1|j,| _,| j,j2rÚ| jdkrÚt| j	dƒ | j,j3rô| j, 4| j	d¡ | jr2|j5s2| js2t6| jƒdk s,| jd jj7s2d| _|  8|¡ |  9|¡ d S )NÚlocalsr,  rê   r#   )r  rR  r  )r  r  z*Suite attached to non-function declarationrV   rá  zBFunction with optional arguments may not be declared public or apir/  r1  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.)rF  r  rº  Údefiningr»  rQ  zFunction cannot return an arrayzused as a return valuer   F):rD  Úis_c_class_methodrR  r†   rÏ   rˆ  Údirective_returnsr<   r   r(   r
   r   rG   r  r¢  rÁ  rM   rj  r"  r¡   r  r  r3   rQ  r:  rq  r  Zcfunc_declaratorrV   r6  rº  r7  r   Úziprõ  r>   rF  Ú_validate_type_visibilityr   rŒ  rý   r»  Úis_pythran_exprr8  rK  r;  rÂ  rØ   Úinline_in_pxdZinline_func_in_pxdrü   r  Zcheck_nullary_constructorr¿  rL   r?   Údeclare_cpdef_wrapperrÿ  )r‡   rE   rG   rT  r3   rj  Zopt_arg_countÚ
formal_argÚtype_argr>   rF  r)   r)   r*   rœ   (	  s˜    

þÿ

ÿÿ

ÿ
ü

 
z!CFuncDefNode.analyse_declarationsc                 C   sH  | j rD| jrt| jdƒ | jj}| j|jd}| jrnddlm	} t
| j|| j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sD|jrtjrDt| j| jd| _t| j| j| j gd| _ d S )Nz&static cpdef methods not yet supported)r¿  r   )r$  rê   r¶  )Ú	decoratorr   )	r(   r>   rV   r  rŽ  r1   r¡   rÆ  rÉ   Trä   )r(  )!rQ  rÁ  r   r(   rØ   r>   Úcall_self_noder¿  r  r$  ÚDecoratorNoder  rv   ÚDefNoderV   r1   r(  rœ   r:  rÛ   r  r
   r   r3   Úas_variablerb  r×   Úis_final_cmethodr   Úlookup_module_cpdefÚOverrideCheckNodeÚoverrider¡   )r‡   rE   r>   Zpy_func_bodyr$  rÆ  r)   r)   r*   rš  …	  sF    ø	



ÿÿz"CFuncDefNode.declare_cpdef_wrapperc                 C   sN   | j dkp| j}t|ddƒ}|rJ|rJ|jrJ|j dv 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á  r1  z:Function declared public or api may not have private types)r  rº  r–   r¿  rð   r   )r‡   r3   r(   rE   Zpublic_or_apirØ   r)   r)   r*   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 r)   r¶  ©r‘   rd  r)   r)   r*   r“   º	  r”   z/CFuncDefNode.call_self_node.<locals>.<listcomp>r¶  )r|  Ú	attributeTr   c                    s   g | ]}ˆ j ˆj|d ‘qS ©r¶  )r$  r(   )r‘   Ún©r  r‡   r)   r*   r“   Ð	  r”   )ÚfunctionrV   Zwrapper_call)r(   rK  r;   )rº   r  r3   rV   rL   r6  r$  r(   rØ   r>   r   r£  rÁ  r[  rH  ZAttributeNodeÚSimpleCallNodeÚReturnStatNoder
   r   )r‡   Zomit_optional_argsr¿  rV   Ú	arg_namesÚcfuncZcall_arg_namesZskip_dispatchZclass_entryZ
class_noder¤  rœ  Zc_callr)   r«  r*   rž  µ	  s6    üzCFuncDefNode.call_self_nodec                 C   s0   | j jD ]"}|jst|jdƒ |  ||¡ qd S )Nrù   )r3   rV   r>   r   r(   rr  rò  r)   r)   r*   Údeclare_argumentsÔ	  s    zCFuncDefNode.declare_argumentsc                 C   s   | j jS r‚   )r3   r9  r÷  r)   r)   r*   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)
r3   r9  r8  rK  r?   r   r(   rý  rÌ  Zin_with_gil_block)r‡   rE   r3   r9  rØ   r)   r)   r*   rÌ   Ý	  s    
ÿzCFuncDefNode.nogil_checkc                 C   sd   |j | j_ | jd ur$| j |¡| _n.| jd ur>| j |¡| _n|  |¡ |  |¡ |  | j¡| _| S r‚   )	rÏ   rý  r  rw   r(  rð  ró  rù  r  r‹   r)   r)   r*   rw   è	  s    




z CFuncDefNode.analyse_expressionsc                 C   s   dS ©NFr)   rì   r)   r)   r*   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 u rÜ| jj}| |d |¡¡}| jjdkrd|vrd}nd}d }| | jj¡}| jj||d	}| j}| jrf|rZ|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ý  r3   rV   rL   r6  rÿ   r  r>   Úcf_usedr&  rQ  r
   rA   r	   Úskip_dispatch_cnamer¥  rc  Úoptional_args_cnamerP  rØ   Ú
func_cnameZfunction_header_coder¯   r  Zbuild_function_modifiersZfunc_modifiersrK  r”  rÝ  rÒ   ÚpartsrS   )r‡   rY   r  Úwith_opt_argsÚwith_dispatchrF  r[  Z	arg_declsr3   rd  Zarg_declrØ   Zdispatch_argÚentityZstorage_classrµ  r»  ÚheaderZneeds_protor)   r)   r*   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 ry  )rý  rV   rø   r  r>   r¥  r¶  rx  rS   r3   rÿ   rF  )r‡   rE   rY   r[  rd  rØ   r™   r)   r)   r*   r-  &
  s    

ÿz+CFuncDefNode.generate_argument_declarationsc                 C   s   d S r‚   r)   rž   r)   r)   r*   r2  0
  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   r  zif (%s->%sn > %s) {r>   z%s = %s->%s;r   r  c                    s:   | j r6ˆ js6ˆ d| j| jf ¡ ˆ | ¡ ˆ | ¡ d S ry  )r.  rø   rS   rF  Úoriginal_cnamerI  Úput_var_giveref©rØ   ©rd  rY   r)   r*   Úput_into_closureM
  s    
zECFuncDefNode.generate_argument_parsing_code.<locals>.put_into_closure)rý  r3   r6  rS   r	   r¸  rV   rø   r  r>   r¥  r¶  r]  rj  rq  r  rF  Zopt_arg_cnameÚranger¢  )
r‡   rE   rY   rS  rb  r[  rØ   rj  r±  rÃ  r)   rÂ  r*   rG  3
  s<    
ÿÿ
ÿÿ


z+CFuncDefNode.generate_argument_parsing_codec                 C   s   d S r‚   r)   rž   r)   r)   r*   Ú!generate_argument_conversion_codeV
  s    z.CFuncDefNode.generate_argument_conversion_codec                 C   s@   | j jD ]2}|jr |  ||¡ q|j jr|js|  ||¡ qd S r‚   )r3   rV   Úneeds_type_testrx  r?   ru  rz  r{  r)   r)   r*   rM  Y
  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ç   r(   rS   rj   rÚ  rÔ   r  rž   rq   r)   r*   rÔ   b
  s    
z$CFuncDefNode.generate_execution_codec                 C   s   | j jrdS | jjjS d S )NÚ0)rK  r?   rØ   r3   r#  r   r)   r)   r*   rX  j
  s    zCFuncDefNode.error_valuec                 C   s
   | j jjS r‚   )rØ   r3   r7  r   r)   r)   r*   rY  q
  s    z)CFuncDefNode.caller_will_check_exceptionsc                 C   s  d}| j }|j}|jd ur|d7 }|j}d| j jtj|f |_| ¡  | j|d|jj|jj	|jd | j
j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»  rF  zreturn c                 S   s   g | ]
}|j ‘qS r)   )rF  r§  r)   r)   r*   r“   ‡
  r”   z;CFuncDefNode.generate_wrapper_functions.<locals>.<listcomp>rÇ  ÚNULLú%s(%s);rª   r  )rØ   r3   Z
prev_entryr¹  r	   r]  rS   r)  r:  r6  rK  rþ   r*  rV   rL   r&  r·  r¸  r¯   )r‡   rY   ÚkrØ   r=  rV   Zarglistr)   r)   r*   ri  t
  s8    ü
"

z'CFuncDefNode.generate_wrapper_functions)r   r   )N)r   r   N)#rO   rr   rs   r•   r™  rÆ  rR  r•  r¥  rÝ  r;  r  r  Úpropertyr9  rœ   rš  r—  rž  r±  rù  rÌ   rw   r&  r)  r-  r2  rG  rÅ  rM  rÔ   rX  rY  ri  rt   r)   r)   rq   r*   rÚ  ý  s>   
]$


-
#	rÚ  c                   @   s    e Zd Zg ZdZdZdd„ ZdS )ÚPyArgDeclNodeFc                 C   s   | j  ||¡ d S r‚   )rØ   rÓ   rì   r)   r)   r*   rÓ   Ÿ
  s    z+PyArgDeclNode.generate_function_definitionsN)rO   rr   rs   r•   r+  rƒ  rÓ   r)   r)   r)   r*   rÌ  ”
  s   rÌ  c                   @   s   e Zd ZdgZdS )rŸ  r  N)rO   rr   rs   r•   r)   r)   r)   r*   rŸ  £
  s   rŸ  c                   @   s  e Zd Zg d¢ZddgZdZdZdZdZdZ	dZ
dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZd	d
„ Zd3dd„Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Z dd„ Z!dd„ Z"dd„ Z#dd„ Z$dd „ Z%d4d!d"„Z&d#d$„ Z'd%d&„ Z(d'd(„ Z)d5d)d*„Z*d+d,„ Z+d-d.„ Z,d/d0„ Z-d1d2„ Z.dS )6r   )rV   r  rŽ  r¡   rÆ  Úreturn_type_annotationrÆ  rÍ  FNrÇ  r   Tc                 K   sl   t j| |fi |¤Ž d } }}| jD ].}|jrF|d7 }|jsF|d7 }|js&|d7 }q&|| _|| _|| _d S r&   )rï  r‰   rV   r…  rø   Únum_kwonly_argsÚnum_required_kw_argsÚnum_required_args)r‡   r(   rW   rÊ  ZrkÚrrd  r)   r)   r*   r‰   Ü
  s    

zDefNode.__init__c	                 C   s  | j rt| j jdƒ | jr(t| jjdƒ |p.d\}	}
|d u r¨g }| jD ]6}|j|dd\}}| tj|j	d |j
t|jd¡ qFtjt|dd |
|||d}t| j|d	}n¬|d u 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 u sB|tju r |j|_||_q |	d u rŠ|jd u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   rn  )r>   rF  rD   r3   r(   F)rK  rV   rP  r#  r7  r8  r9  r:  r‹  zwrong number of argumentszprevious declaration herer   r*  r2  r4  rª  )r  rV   rP  r7  r#  r9  r8  r´  rR  )r»  rG   rj  r¡   r1   rQ  r3   r9  r8  r  rº  rR  r•  )%r  r   r(   rŽ  rV   r  r&  r
   rI  r>   rD   r   rO  rî   r[  r3   rL   rP  rC  r–  rD  rT  r#  r  r3  rK  r"  r÷   r7  r9  r8  rÚ  rC   r¡   r1   r:  r–   )r‡   r°  r[  rQ  ÚreturnsZ
except_valr»  r8  r9  r#  r7  Z
cfunc_argsr›  rT  r3   Z
cfunc_typerS  rœ  r3  rj  r)   r)   r*   Ú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   r)   r)   r*   Úis_cdef_func_compatible-  s
    zDefNode.is_cdef_func_compatiblec              	   C   sX  | 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dkrˆ|jrˆd| _|  |¡ | jdkr¨|  	|¡ n
|  
|¡ |  |¡ | jj ¡ | _| jtu r| jr|jd r| jjst| j|ƒ\}}|r|jr|| _|  |¡ t| j| | jj| j| j| j| jd| _| j |¡ d S )	NÚclassmethodrê   Frk   r   ú<lambda>rm  )r€  r>   rV   r  rŽ  rK  )rÆ  r  r=   Úis_classmethodr>   Úis_staticmethodr¢  rû  Úanalyse_argument_typesÚdeclare_lambda_functionÚdeclare_pyfunctionÚanalyse_signaturerØ   Ú	signaturerK  r   rÍ  rÏ   rd  rI   r?   rÿ  ÚDefNodeWrapperr(   rV   r  rŽ  Ú
py_wrapperrœ   )r‡   rE   r  r_   r±  rK  r)   r)   r*   rœ   8  sD    





ùzDefNode.analyse_declarationsc                 C   sÎ  |j  di ¡| _|j d }|j}d |_| jD ]l}t|dƒrBd }nV|j |¡}t|ƒrl|j	rlt
 ||jg¡}|j ||¡\}}|j|_||_|jr˜d| _|  ||¡ |rº|jrºt| jdƒ |j ¡ |_d |_d|_d|_d|_|jjsø|jjsø|jjrn|jrd|_nd|j rd|_nT|jj!s@|jj"s@|jjs@|jjrf|j#r^|j#j$d u r^d|_n||_nd|_q,d|_|j rˆt|jd	ƒ |jr,t|jd
ƒ q,||_t|ƒrÄdd„ t%| jƒD ƒ| _&ng | _&d S )Nr‘  Úallow_none_for_extension_argsr>   Tz9Python function argument cannot have C name specificationr   r   Fz.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 r)   )r3   Zis_numpy_buffer)r‘   rS  Úar)   r)   r*   r“   ¡  r”   z2DefNode.analyse_argument_types.<locals>.<listcomp>)'rÏ   rˆ  rR  r  rV   rq  rG   r  r    r˜  r
   r·  Z
org_bufferrj  r>   r3   r   rŒ  rõ  rF  r   r(   Zas_argument_typeÚhdr_typeÚneeds_conversionrÆ  r„  r?   rý   rÀ  r‡  ru  r†  Úis_extension_typerv  rø   Úconstant_resultrC  Únp_args_idx)r‡   rE   rà  Zf2srd  rT  rG   r3   r)   r)   r*   rÙ  e  sd    

ýÿ
ÿÿ
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
d s| js| js| j jtju r¶t| jƒdkr€tj| j _n4t| jƒdkr´| jd jd u r´| jd js´tj| j _nd| j jtju rt| jƒdkràtj| j _n:t| jƒdkr| jd jd u r| jd jstj| j _| j j}| ¡ }|tju rp|dkrpt| jƒdkrp| jrpt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|_"| #|¡rR| jsR| jr6d|_$t%j& |_'|_(nd|_#|j) |_'|_(d|_*n>| +|¡|_'|j( ,|j'¡s|j'j-rŠ|j(j-rŠd|_.nd|_*|j*r¨t/j0|j1 |_2nt/j3|j1 |_2qð|t| jƒkrÖ|  4¡  d S |t| jƒk r&|jsö|  4¡  | jD ](}|j"rü|j(j5s|j(j6rüd|_.qüd S )Nz8special functions of cdef classes cannot have decoratorsr   Zalways_allow_keywordsr   r#   Tr5  )7rØ   rd  rÆ  r   r(   rL   rV   r  rŽ  Ztrivial_signaturerÏ   rÝ  r   Zpyfunction_signatureZpyfunction_noargsrø   r…  Zpyfunction_oneargZpymethod_signatureZ	unaryfuncZibinaryfuncÚnum_fixed_argsÚself_in_starargrØ  rD  r   Zfixed_arg_formatÚhas_generic_argsr×  rŒ  Zdecorator_indirectionrÜ   rÄ  Úminr„  r+  rƒ  r   Z	type_typerâ  r3   rH  rã  Zfixed_arg_typerE  r?   rÆ  r	   Z
arg_prefixr>   Ú	hdr_cnameZ
var_prefixÚbad_signaturerä  rv  )r‡   rE   ÚsigZnfixedrS  rd  r)   r)   r*   rÜ  ¥  s†    " 
ÿÿÿÿ

zDefNode.analyse_signaturec                 C   sj   | j j}d| ¡  }|jr"|d7 }| j}| d¡rB| d¡rBd}nd}t| jd|| jt	| j
ƒ|f ƒ d S )Nz%dz or moreÚ__zSpecial methodZMethodz>%s %s has wrong number of arguments (%d declared, %s expected))rØ   rÝ  rç  ré  r>   Ú
startswithÚendswithr   r(   rL   rV   )r‡   rí  Zexpected_strr>   Údescr)   r)   r*   rì  ò  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j| | | j_tjröt| j| jƒ|_tj| | |_|jrü|j tjv sÜ|jrÜ|j dv rä|jd räd |_qü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¢  rH  Úis_final_typer   r(   r3   r  Zis_builtin_cmethodrÉ   r   rÛ  rØ   Únext_idÚscope_prefixr	   Zpyfunc_prefixÚpyfunc_cnamer   rÅ  r2   r1   Zfuncdoc_prefixÚ	doc_cnamerd  r   Z	invisiblerÏ   Úwrapperbase_cnameZwrapperbase_prefix)r‡   rE   r>   rØ   Úprefixr)   r)   r*   rÛ  ÿ  s.    
ÿÿzDefNode.declare_pyfunctionc                 C   s*   |  | j| j¡}d |_|| _|j| j_d S r‚   )rÚ  Úlambda_namer(   r1   rØ   rF  r÷  )r‡   rE   rØ   r)   r)   r*   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   )rV   r>   r   r(   rã  r^  r3   rØ   r?   rl  rr  r8   rb  r+  Údeclare_python_argr  rŽ  rò  r)   r)   r*   r±    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   r^  r>   r(   r8   rb  rl  rK  rØ   )r‡   rE   rd  r3   rØ   r)   r)   r*   rü  .  s    zDefNode.declare_python_argc                 C   sx   |j | j_ |  |¡ |  |¡ | jr4|  || j¡| _|  |¡sh| jrh| jd d d… D ]}|j 	|¡|_qT| j
 |¡ | S )Nr½   )rÏ   rý  rð  ró  rÍ  rñ  r&  rÆ  r  rw   rß  Úprepare_argument_coercion)r‡   rE   r  r)   r)   r*   rw   ;  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 u r^| j	j
d S |jj
d S |jpt|jS )NTFZbinding)rØ  Úspecialized_cpdefsrØ   Zis_fused_specializedÚno_assignment_synthesisrd  Zis_anonymousr¿  rD  rý  rÏ   rÒ   rû  r  rì   r)   r)   r*   r&  I  s    z"DefNode.needs_assignment_synthesisc                 C   s
   | j jjS r‚   )rØ   rÝ  rX  r   r)   r)   r*   rX  [  s    zDefNode.error_valuec                 C   s
   | j jjS r‚   )rØ   rÝ  r7  r   r)   r)   r*   rY  ^  s    z$DefNode.caller_will_check_exceptionsc                 C   sJ   | j r| j  | ¡ |¡ | jr8| jj| j_| j ||¡ t | ||¡ d S r‚   )Údefaults_getterrÓ   rÖ   Úpy_wrapper_requiredrØ   r¹  rß  rï  rì   r)   r)   r*   rÓ   a  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Ø   r.  r¿  rF  r3   rÿ   r¶  )rd  rØ   rF  Údeclr)   r)   r*   Úarg_decl_codez  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	   rD  r,  r&  rV   r  rŽ  r¯   rK  rÿ   r÷  rÒ   r   rS   )r‡   rY   r  r  Úarg_code_listÚself_argr  rd  rw  ÚdcZ
decls_coderj  r)   r)   r*   r)  m  sB    ÿ






ÿ
z DefNode.generate_function_headerc                 C   s   d S r‚   r)   rì   r)   r)   r*   r-  ›  s    z&DefNode.generate_argument_declarationsc                 C   s   d S r‚   r)   rž   r)   r)   r*   r2  ž  s    zDefNode.generate_keyword_listc                    sF   ‡ fdd„}| j D ]}||jƒ q| j| jfD ]}|r.||jƒ q.d S )Nc                    sP   | j rLˆ  d| j| jf ¡ | jr8ˆ  | ¡ ˆ  | ¡ nˆ  | ¡ ˆ  | ¡ d S ry  )	r.  rS   rF  r¿  rK  rL  Zput_var_xgiverefrI  rÀ  rÁ  ©rY   r)   r*   rÃ  £  s    

z@DefNode.generate_argument_parsing_code.<locals>.put_into_closure)rV   rØ   r  rŽ  )r‡   rE   rY   rÃ  rd  r)   r  r*   rG  ¡  s    
z&DefNode.generate_argument_parsing_codec                 C   s   d S r‚   r)   rž   r)   r)   r*   rM  ´  s    z$DefNode.generate_argument_type_tests)NNTNNNFF)N)r   )/rO   rr   rs   r•   rË   rØ  r×  rû  Zreqd_kw_flags_cnamerÉ   rÿ  rÆ  rÍ  rØ   r  rè  Zpy_cfunc_nodeÚrequires_classobjÚdefaults_structr1   Úfused_py_funcrþ  rß  r  r¹  r   r‰   rÓ  rÔ  rœ   rÙ  rÜ  rì  rÛ  rÚ  r±  rü  rw   r&  rX  rY  rÓ   r)  r-  r2  rG  rM  r)   r)   r)   r*   r   ª
  s\     ÿ
C-@M

.r   c                   @   sÞ   e 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d5d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/d0„ Zd1d2„ Zd3d4„ ZdS )6rÞ  Nc                 O   sJ   t j| g|¢R i |¤Ž | jj| _| jj| _| jj| _| jj| _d | _d S r‚   )rï  r‰   r€  rÎ  rÏ  rÐ  rè  rÝ  )r‡   rV   rz   r)   r)   r*   r‰   ¾  s    



zDefNodeWrapper.__init__c                 C   sP   | j j}| j}| |j¡}tj| | |_tj| | |_	|j
| _
| j j| _d S r‚   )r€  rØ   r>   rõ  rö  r	   Zpywrap_prefixr¹  Zpymethdef_prefixÚpymethdef_cnamerÝ  ræ  )r‡   rE   Ztarget_entryr>   rú  r)   r)   r*   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)rV   r3   r?   Úcreate_from_py_utility_coderâ  rÃ  rŽ  rØ   r¶  rK  rH  r8   rn  r=   Zcf_maybe_null)r‡   rE   rd  rØ   Zassr)   r)   r*   rý  Ñ  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&   )rL   rV   r+  rƒ  )r‡   Zargcountr)   r)   r*   Úsignature_has_nongeneric_argsç  s    
ÿ
ÿ
þz,DefNodeWrapper.signature_has_nongeneric_argsc                 C   s   | j jS r‚   )rÝ  ré  r   r)   r)   r*   Úsignature_has_generic_argsï  s    z)DefNodeWrapper.signature_has_generic_argsc                 C   sÒ   g }| j jr| tj¡ | jD ]H}|jrX|jjsX|jj	sX|jj
sX| |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 )Nrª   z%s = rÉ  )rÝ  r  r&  r	   rD  rV   râ  r3   rÀ  r×  r”  rw  rØ   rF  r  rŽ  r¯   rK  rþ   r*  r0  rS   r€  r÷  )r‡   rY   rV   rd  r)   r)   r*   r   ò  s*    
ÿþ

ÿ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 ¡ | ¡  | d| j ¡ |  ||¡ |  |¡ |  |¡ | |j¡ | | j¡ | d¡ | d¡ |j|jv r’| |j¡ |  |j¡ |j !¡ D ]\}}	| "||	¡ qT|  #¡ }
|
d ur’| dtj|
f ¡ |  |j¡ |j$D ]"}|j%r¤|j&jr¤| '|¡ q¤| (¡  | jjsê| dtj ¡ | d	¡ | )¡  |r| d
| ¡ d S )Nrº   z/* Python wrapper */z = 0r
  z%s (wrapper)r  rz  r  r  r  )*r€  rý  rç   r(   rS   r   r"  r#  r$  r&  r'  r)  r-  r1  rK  r?   rþ   rÿ   r	   r0  r=  r>  r>   rG  rM  r   rg  rã  rP  rQ  rR  rS  rT  rU  rV  rX  rÌ  r8   r3   r`  rf  rh  )r‡   rE   rY   rø  rj  r  rm  Zretval_initrF  r3   rp  rØ   r)   r)   r*   rÓ     sf    





ÿþ







z,DefNodeWrapper.generate_function_definitionsr   c                 C   sB  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jrÀ|jdkrÀ| d¡ |jrÜ| dtjtjf ¡ d |¡}d}	|jdv r|jjrd}	d	}| j |j¡}
d
|	|
|f }| d| ¡ |rZ| jjrV| jjj||dd d S tj rü|j!rü| jjsü|jj"sü|jrŽ|j#rü|j!}|j$r¤| %¡ }|jr¸|jdv sÐ| d|j&| '¡ f ¡ |jrü| d¡ | d|j# ¡ | d¡ |s| jjr0| (d|j) ¡ |j*| jjdd	d | d| ¡ d S )Nr  r  zCYTHON_UNUSED PyObject *unusedÚ__ipow__zPyObject *%s, PyObject *%srª   rº   r†  Fzstatic %s%s(%s)z%s; /*proto*/T)r  zstatic char %s[] = %s;ú#if CYTHON_COMPILING_IN_CPYTHONzstruct wrapperbase %s;r  zstatic PyMethodDef %s = r  )Z
allow_skipz%s {)+rÝ  r  rè  r	   rD  r&  rV   r„  r+  rƒ  rë  râ  rÿ   r€  rØ   rd  Zmethod_flagsr   Zmethod_noargsr[  rD  r>   ré  Ú
args_cnameÚ
kwds_cnamer¯   rK  r¹  rS   r  r)  r   rÅ  r1   Zis_property_scoperù  Z
is_unicodeZas_utf8_stringrø  Zas_c_string_literalr*  r  Zput_pymethoddef)r‡   rY   r  r  r  rí  rw  rd  rØ   Zmfr
  r¾  Zdocstrr)   r)   r*   r)  H  sŒ    


ÿ

ÿÿ
ÿ
ÿÿþýýþ
ÿ
ÿz'DefNodeWrapper.generate_function_headerc                 C   sV   | j D ].}|jr|jr(| d|j ¡ q| |j¡ q|jD ]}|jr<| |¡ q<d S )NzPyObject *%s = 0;)	rV   r„  rã  rS   rë  r/  rØ   rÌ  r8   )r‡   rE   rY   rd  rØ   r)   r)   r*   r-  “  s    

z-DefNodeWrapper.generate_argument_declarationsc           	      C   s\  |  ¡ }|j}| d¡}| jdk}| jd up8| jd up8|}| jD ]}|jjs@|j 	|¡s@q@|  
¡ s~|rrt| jdƒ |  |¡ n$|  ¡ s’|  |¡ n|  | j||¡ ||_| |¡rB| |¡sÈ| |¡ | |¡ |r|  | j|¡ | jr| jjjr
| | jj¡ n| | jj¡ | | jjj¡ | ¡  | d|  ¡  ¡ | |¡rX| |¡ d S )NZargument_unpacking_doner   z.This method cannot have * or keyword argumentsr  )Únew_error_labelrP  r#  rÎ  r  rŽ  rV   r3   r?   r  r  r   r(   rÅ  r  Úgenerate_stararg_copy_codeÚ'generate_tuple_and_keyword_parsing_codeÚ
label_usedrR  rT  Úgenerate_arg_decrefrØ   rK  Úput_var_xdecref_clearÚput_var_decref_clearrZ  r€  r[  rf  rS   rX  )	r‡   rE   rY   Úold_error_labelÚour_error_labelÚ	end_labelZhas_kwonly_argsZhas_star_or_kw_argsrd  r)   r)   r*   rG  ž  sH    


ÿÿ



z-DefNodeWrapper.generate_argument_parsing_codec                 C   s   |r|  |j¡ d S r‚   )r  rØ   ©r‡   rd  rY   r)   r)   r*   Úgenerate_arg_xdecrefÌ  s    z#DefNodeWrapper.generate_arg_xdecrefc                 C   s   |r|  |j¡ d S r‚   )r  rØ   r!  r)   r)   r*   r  Ð  s    z"DefNodeWrapper.generate_arg_decrefc              	   C   sj  | j sP|j t dd¡¡ | dtj ¡ | d| j	tj|  
¡ f ¡ | d¡ | jr~| j sf| jjjsrdtj }qŽdtj }ndtjtjf }|j t d	d¡¡ | d
|tj| j	t| jƒ|  
¡ f ¡ | jrÆ| jjjrÆtdd„ | jjjD ƒƒrr| d| ¡ | d| jjjtj| jjj|  
¡ f ¡ | | jjj¡ | d¡ | d| jjjf ¡ | d¡ d| jj_nT| d| jjjtjtjf ¡ | d| jjj|  
¡ f ¡ d| jj_| | jjj¡ | jr,| jjs,| d| j jjtj| j jjf ¡ | jrH| jjjrH| d¡ | | jjjt¡ | d|  
¡  ¡ | d¡ n| d|  
¡  ¡ | | j jj¡ | tjt¡ | tj¡ | d| j jjtjf ¡ |jjtj dd}| d||tj|f ¡ | dtj|f ¡ | dt¡ | d¡ | d| j jj|f ¡ | d¡ |j !|¡ d| j j_n:| j rf| tjt¡ | d| j jjtjf ¡ d| j j_d S ) NÚRaiseArgTupleInvalidrs  z)if (unlikely(PyTuple_GET_SIZE(%s) > 0)) {zK__Pyx_RaiseArgtupleInvalid("%s", 1, 0, 0, PyTuple_GET_SIZE(%s)); return %s;r  zunlikely(%s)ú%sz-unlikely(%s) && unlikely(PyDict_Size(%s) > 0)ZKeywordStringCheckzHif (%s && unlikely(!__Pyx_CheckKeywordStrings(%s, "%s", %d))) return %s;c                 s   s   | ]}|j jV  qd S r‚   )rX   Z
allow_null)r‘   Úrefr)   r)   r*   rï   î  r”   z<DefNodeWrapper.generate_stararg_copy_code.<locals>.<genexpr>r  z3%s = PyDict_Copy(%s); if (unlikely(!%s)) return %s;r  ú
%s = NULL;r   z,%s = (%s) ? PyDict_Copy(%s) : PyDict_New(); zif (unlikely(!%s)) return %s;r   z=%s = PyTuple_New(PyTuple_GET_SIZE(%s)+1); if (unlikely(!%s)) r  r  zPyTuple_SET_ITEM(%s, 0, %s);Frâ  z-for (%s=0; %s < PyTuple_GET_SIZE(%s); %s++) {z*PyObject* item = PyTuple_GET_ITEM(%s, %s);r«   z!PyTuple_SET_ITEM(%s, %s+1, item);rz  )"r  rÒ   rŸ  r   r!  rS   r	   r  r*  r>   rX  rŽ  rØ   r¶  r  Úboolrñ   Zcf_referencesrF  rç  rK  rè  r€  rØ  Úput_xdecref_clearr   rB  rD  r}  rã  rä  r
   Úc_py_ssize_t_typerê  )r‡   rY   Zkwarg_checkrë  r)   r)   r*   r  Ô  s¶    
ÿÿÿ
ÿ
ÿ
þÿü

ýÿ
ý
ÿ
ÿÿ

ÿ
þz)DefNodeWrapper.generate_stararg_copy_codec              	      s„  ˆ   d¡}g }g }g }|D ]b}|jr|jrT|js||js||jrH| |¡ q|| |¡ q|jrf| |¡ q|js|js| |¡ 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tjd ‡ fdd„|D ƒ¡f ¡ |  |ˆ ¡ ˆ  d	| jdkrXd
pZdtjf ¡ |  |
|||||ˆ ¡ | jrŽ|
dks˜|
|krÔ|
|kr°| j
s°d}nd}ˆ  dtj||
f ¡ ˆ  |¡ | jr‚||
kr| j
sˆ  dtj|f ¡ ˆ  |¡ ˆ  d¡ t|	ƒD ]^\}}|jsˆ  |j¡}ˆ j t dd¡¡ ˆ  d| j|f ¡ ˆ  ˆ   | j!¡¡  qäqnbˆ  d¡ |
|krÄt|ƒD ] \}}ˆ  d|tj|f ¡ qžn ˆ  dtj ¡ | j
ræˆ  d¡ t"t|ƒƒd d d… }|D ]\\}}||
d krD||d d kr2ˆ  d¡ ˆ  d|d  ¡ ˆ  d|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¡ ˆ  %|¡r€ˆ  |¡ ˆ  &|¡ ˆ j t d d¡¡ ˆ  d!| j||
|tjf ¡ ˆ  ˆ   | j!¡¡ d S )"NZargtuple_errorr   r   r  z static PyObject **%s[] = {%s,0};ú,c                    s   g | ]}d ˆ   |j¡ ‘qS ©ú&%s)Úintern_identifierr>   r§  r  r)   r*   r“   O  s   ÿzJDefNodeWrapper.generate_tuple_and_keyword_parsing_code.<locals>.<listcomp>zif (%s(%s)) {Úlikelyr^  z!=ú<z(} else if (PyTuple_GET_SIZE(%s) %s %d) {z'} else if (PyTuple_GET_SIZE(%s) > %d) {r  ÚRaiseKeywordRequiredrs  ú&__Pyx_RaiseKeywordRequired("%s", %s); ú&values[%d] = PyTuple_GET_ITEM(%s, %d);zswitch (PyTuple_GET_SIZE(%s)) {údefault:r½   úCYTHON_FALLTHROUGH;ú
case %2d: z	case  0: úbreak;ú	case %2d:ú	default: r  z
values[%d]r#  zD__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, PyTuple_GET_SIZE(%s)); )'r#  r„  rø   r+  rƒ  r…  r&  rÐ  rÏ  rL   r  r'  rŽ  Úgenerate_stararg_init_coderS   Útupler	   Úpykwdlist_cnamer¯   Ú#generate_argument_values_setup_coder  Úgenerate_keyword_unpacking_coder  rR  rC  r-  r>   rÒ   rŸ  r   r!  r*  rè  r(   r—   rÄ  Úgenerate_arg_assignmentr  rT  )r‡   rV   Zsuccess_labelrY   Úargtuple_error_labelr¥  Zrequired_kw_only_argsZoptional_kw_only_argsrd  Zkw_only_argsÚmin_positional_argsÚmax_positional_argsÚhas_fixed_positional_countÚhas_kw_only_argsÚall_argsÚcomparerS  Úpystring_cnameZreversed_argsr)   r  r*   r  )  sâ    
 ÿ
ÿþþýÿ
ÿ


ÿþ















ÿý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jdd | d¡ nt|jd|j  ƒ d S )Nrz  r  r  Tr  r  ú2Cannot convert Python object argument to type '%s')r3   r?   r„  r
   Ztypecastr   rØ   rS   rF  Úfrom_py_functionrø   Úfrom_py_call_coder(   rx  rÀ  rJ  r   )r‡   rd  r«   rY   rØ   r)   r)   r*   r>  ¼  s.    
ÿ
þ
ÿz&DefNodeWrapper.generate_arg_assignmentc                 C   s*  | j rDd| j j_| d| j jj| j jj|  ¡ f ¡ | | j jj¡ | jr&d| jj_| dtj	|f ¡ | d| jjjtj	|tj	f ¡ | d| jjj ¡ | j r¶| 
| j jjt¡ | ¡  | d|  ¡  ¡ | d¡ | | jjj¡ | d¡ | d	| jjjtjf ¡ | tjt¡ | d¡ d S )
Nr   z0%s = PyDict_New(); if (unlikely(!%s)) return %s;z if (PyTuple_GET_SIZE(%s) > %d) {z4%s = PyTuple_GetSlice(%s, %d, PyTuple_GET_SIZE(%s));r  r  r  r  z	%s = %s; )rŽ  rØ   rK  rS   rF  rX  rç  r  r	   r  ré  r   rf  r*  rA  rB  )r‡   rA  rY   r)   r)   r*   r9  Ö  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
 |¡f ¡ qVd S )NzPyObject* values[%d] = {%s};r*  rÇ  z+%s *%s = __Pyx_CyFunction_Defaults(%s, %s);zvalues[%d] = %s;)rL   rS   r¯   r€  r  r	   Zdynamic_args_cnamerD  rC  rø   r3   r?   rx  rc  )r‡   rV   rY   Zmax_argsrS  rd  ru  r)   r)   r*   r<  ò  s    ÿ

þ
z2DefNodeWrapper.generate_argument_values_setup_codec                 C   sŠ  |  d¡ |  dtj ¡ |  d¡ | jr4|  d¡ t|d ddƒD ]6}| d|d  ¡ |  d|tj|f ¡ |  d	¡ qD|  d
¡ | js | d¡ | |¡ |  d¡ |  dtj ¡ | jsÊ|dkrÜd}	t	|ƒD ]\}}
|
j
sÖ|}	qÖ|	|k rú|d }	|dkr|  d¡ t	|d |	d … ƒD ]¢\}}
|dkr€||kr€|dkrT|  d	¡ | jrr||krr|  d¡ n|  d| ¡ | |
j¡}|
j
rØ|
jr q"|  d¡ |  dtj|f ¡ |  d| ¡ |  d¡ nì|  d|tj|f ¡ ||k rn|dkr| d¡ | |¡ nT|  d¡ |j t dd¡¡ | d| j||||f ¡ |  | | j¡¡ |  d¡ nV|
jr"|  d¡ |j t dd¡¡ | d| j|f ¡ |  | | j¡¡ |  d¡ q"|dkrÜ|  d¡ |rî|  ||¡ |  d¡ |dkrd}n$| jr(|  d||f ¡ d}nd}|j t d d¡¡ |  d!tjtj| jrb| jjjpdd|| j| | j¡f ¡ |  d¡ d S )"NzPy_ssize_t kw_args;z1const Py_ssize_t pos_args = PyTuple_GET_SIZE(%s);zswitch (pos_args) {r3  r   r½   r5  r2  r4  zcase  0: break;r8  r  zkw_args = PyDict_Size(%s);r   r7  zif (kw_args > 0) {z2PyObject* value = __Pyx_PyDict_GetItemStr(%s, %s);z-if (value) { values[%d] = value; kw_args--; }zKif (likely((values[%d] = __Pyx_PyDict_GetItemStr(%s, %s)) != 0)) kw_args--;zelse úelse {r#  rs  z2__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, %d); r0  r1  zif (unlikely(kw_args > 0)) {rÇ  zAconst Py_ssize_t used_pos_args = (pos_args < %d) ? pos_args : %d;Zused_pos_argsZpos_argsZParseKeywordszOif (unlikely(__Pyx_ParseOptionalKeywords(%s, %s, %s, values, %s, "%s") < 0)) %s)rS   r	   r  r  rÄ  r*  rR  r  rÐ  rC  rø   r-  r>   r…  rÒ   rŸ  r   r!  rè  r(   Ú,generate_optional_kwonly_args_unpacking_coder;  rŽ  rØ   rF  )r‡   r@  rA  rB  rC  rD  r?  rY   rS  Zlast_required_argrd  rF  Zpos_arg_countr)   r)   r*   r=    s¾    


ÿ








ÿÿ




ÿþ

ÿÿ



ÿ
ÿ
úz.DefNodeWrapper.generate_keyword_unpacking_codec                 C   sð   g }d}t |ƒD ]*\}}|jr|js&q|s.|}| |j¡ q|rìt|ƒdkr”| d| j r^dp`dt|ƒf ¡ | d¡ | d||t|ƒ f ¡ n| d¡ | d	| ¡ | d
tj	tj
f ¡ | d¡ t|ƒdkrâ| d¡ | d¡ d S )Nr½   r   z'if (kw_args > 0 && %s(kw_args <= %d)) {r.  rº   z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_PyDict_GetItemStr(%s, *%s[index]);z0if (value) { values[index] = value; kw_args--; }r  )rC  r…  rø   r&  r>   rL   rS   rŽ  r	   r  r;  )r‡   rD  rY   Zoptional_argsZfirst_optional_argrS  rd  r)   r)   r*   rK  ~  s6    þ
ÿ

ÿ

z;DefNodeWrapper.generate_optional_kwonly_args_unpacking_codec                 C   s"   | j D ]}|jr|  ||¡ qd S r‚   )rV   rã  Úgenerate_arg_conversionr{  r)   r)   r*   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 )Nr  zassert(%s); {r  rz  z+Cannot convert 1 argument from '%s' to '%s')râ  r3   r?   rø   rS   rë  Ú%generate_arg_conversion_from_pyobjectÚ#generate_arg_conversion_to_pyobjectrN  rØ   rF  r   r(   )r‡   rd  rY   Úold_typeÚnew_typer)   r)   r*   rL  ¥  s    
z&DefNodeWrapper.generate_arg_conversionc                 C   s@   |j }|jr,| | |j|jj|j|¡¡ nt|jd| ƒ d S )NrG  )	r3   rH  rS   rI  rë  rØ   rF  r(   r   )r‡   rd  rY   rP  r)   r)   r*   rM  ¸  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_functionrS   rØ   rF  rë  ræ  r(   Zput_var_gotrefr   )r‡   rd  rY   rO  r_   r)   r)   r*   rN  Å  s    üz2DefNodeWrapper.generate_arg_conversion_to_pyobjectc                 C   sN   | j D ]B}|jr|  ||¡ q|js|jjs<|jjs<|jjr|  ||¡ qd S r‚   )	rV   rÆ  rx  ru  r3   r?   rý   rÀ  rz  r{  r)   r)   r*   rM  Ò  s    
ÿþz+DefNodeWrapper.generate_argument_type_testsc                 C   s   | j jS r‚   )rÝ  rX  r   r)   r)   r*   rX  Þ  s    zDefNodeWrapper.error_value)r   )rO   rr   rs   Zdefnoder€  r‰   rœ   rý  r  r  r   rÓ   r)  r-  rG  r"  r  r  r  r>  r9  r<  r=  rK  rÅ  rL  rM  rN  rM  rX  r)   r)   r)   r*   rÞ  ¸  s8   A
K.U yrÞ  c                       s`   e Zd ZdZdZdZdZdZdZe	j
dg Z
‡ fdd„Z‡ fdd„Zd	d
„ Z‡ fdd„Z‡  ZS )ÚGeneratorDefNodeTFÚ	GeneratorÚgbodyc                    s.   t |g dd|d< tt| ƒj|fi |¤Ž d S )NT)rÜ   rÈ   r¡   )rÛ   rj   rQ  r‰   ©r‡   r(   rz   rq   r)   r*   r‰   ñ  s    zGeneratorDefNode.__init__c                    s*   t t| ƒ |¡ | j| j_| j |¡ d S r‚   )rj   rQ  rœ   rý  rS  r‹   rq   r)   r*   rœ   ö  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¡ | |¡ | ¡  | d¡ | d¡ d S )	Nr  zk__pyx_CoroutineObject *gen = __Pyx_%s_New((__pyx_coroutine_body_t) %s, %s, (PyObject *) %s, %s, %s, %s); %srÈ  Úgenzgen->classobjz&%s = __Pyx_CyFunction_GetClassObj(%s);zreturn (PyObject *) gen;r  )rS  rØ   r¹  r-  r>   ÚqualnameÚmodule_namerS   Úgen_type_namer9  r:  r	   r  ræ  r(   ra  r   r  rD  rB  r}  rf  )r‡   rE   rY   Z
body_cnamer>   rV  rW  Zclassobj_cnamer)   r)   r*   r   û  s.    


üÿÿ

z'GeneratorDefNode.generate_function_bodyc                    sH   |  t | jd¡¡ | jj|dd tt| ƒ ||¡ | j ||¡ d S )NúCoroutine.cT)Úproto)	rŸ  r   r!  rX  rS  r)  rj   rQ  rÓ   rì   rq   r)   r*   rÓ     s    z.GeneratorDefNode.generate_function_definitions)rO   rr   rs   r7  Úis_coroutineÚis_iterable_coroutineÚis_asyncgenrX  rü  r   r•   r‰   rœ   r   rÓ   rt   r)   r)   rq   r*   rQ  â  s   rQ  c                   @   s   e Zd ZdZdZdS )ÚAsyncDefNodeÚ	CoroutineTN)rO   rr   rs   rX  r[  r)   r)   r)   r*   r^    s   r^  c                   @   s   e Zd ZdZdZdS )ÚIterableAsyncDefNodeZIterableCoroutineTN)rO   rr   rs   rX  r\  r)   r)   r)   r*   r`    s   r`  c                   @   s   e Zd ZdZdZdS )ÚAsyncGenNodeZAsyncGenTN)rO   rr   rs   rX  r]  r)   r)   r)   r*   ra  $  s   ra  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)r(   r¡   r>   Úis_async_gen_bodyr1   rV   r  rŽ  )rj   rb  r‰   )r‡   r(   r>   r¡   rc  rq   r)   r*   r‰   2  s    
þzGeneratorBodyDefNode.__init__c                 C   s\   |  |j¡}|  d¡}tj| | }|jd t| j|dd}||_t| j	ƒ|_
d|_|| _d S )NÚ	generatorr´  )rF  r  T)rõ  rö  r	   Zgenbody_prefixr^  r   r(   r¹  r   r>   r[  rb  rØ   )r‡   rE   rú  r>   rF  rØ   r)   r)   r*   Údeclare_generator_body7  s    
ÿz+GeneratorBodyDefNode.declare_generator_bodyc                 C   s   |   |¡ |  |¡ d S r‚   )rÙ  re  r‹   r)   r)   r*   rœ   E  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_cnamerS   )r‡   rY   rZ  r¾  r)   r)   r*   r)  I  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 ur¾| j$}|t%j&u r`d}n0|t%j'u rrd	}n|t%j(u r„d
}nt)d| ƒ‚| 	dtj|| !tj| j¡f ¡ | *tj¡ |  +||¡ |jjjj,r| 	d|jj -tj.¡|jj /dtj0 ¡f ¡ | 	dtj. ¡ |s"|r*d|j_| | j¡ | 	d¡ | 	d¡ | j#s’| jj1s’| j2rx|j 3t4 5dd¡¡ | 	d| j2rŠdnd ¡ | 6|j7¡rP| jj1s¶| 8|j9¡ |  |j7¡ | j#rä| j$d urä| :tjt;¡ t<j=| >¡ j?j@v r |j 3t4 5dd¡¡ | 	dtA| j2ƒ ¡ |j B¡ D ]\}}| C||¡ q*| D| jj¡ |  |j9¡ | j#rr| Etj¡ n| :tjt;¡ | 	d¡ | 	dtj0 ¡ | 	d¡ | 	dtj0 ¡ | 	dtj0 ¡ |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j0 ¡ |	 	d"|
 ¡ |jKD ]\}}|	 	d#||f ¡ q`|	 	d$¡ |s”|r¨|	jFd%|jjG d |	 H¡  |	 	d&¡ |	 	d ¡ | L¡  d S )'Nrº   zPyObject *%s = NULL;r  r  TZ	first_runr$  zPyList_New(0)zPySet_New(NULL)zPyDict_New()z)invalid type of inlined comprehension: %sz%s = %s; %srz  z%s->closurezCYTHON_MAYBE_UNUSED_VAR(%s);Fr  ÚStopAsyncIterationrY  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);r  r  r  zswitch (%s->resume_label) {zcase 0: goto %s;zcase %d: goto %s;z2default: /* CPython raises the right error here */r  zreturn NULL;)Mrý  r¡   rÓ   r"  r#  r$  rç   r(   rÙ   rS   r)  r1  r	   r0  r=  r>  rØ   r>   r[  rÒ   rÏ   r8  rã  rF  r9  r:  r;  Zinit_closure_tempsr+  r3   r[  Z	use_labelrT  ræ  rg  Ú
is_inlinedÚinlined_comprehension_typer   Z	list_typeÚset_typeÚ	dict_typer   rç  r   rÌ  rÿ   r  rw  rf  rÈ   rc  rŸ  r   r!  r  rP  rR  rS  r(  r   r   Úgenerator_stoprÖ   ÚcontextZfuture_directivesr'  rU  rV  rZ  rb  re  r%  rf  rg  rE  Zyield_labelsrh  )r‡   rE   rY   rø  Zclosure_init_coderm  r  r  r9  Zresume_codeZfirst_run_labelÚtarget_typeZ	comp_initrF  r3   rS  Úlabelr)   r)   r*   rÓ   T  sä    







ÿÿþ
ÿþ


ÿÿ


ÿ
ÿÿ
ÿ

z2GeneratorBodyDefNode.generate_function_definitions)NNNF)F)rO   rr   rs   r‹  ri  rc  rj  r‰   re  rœ   r)  rÓ   rt   r)   r)   rq   r*   rb  )  s   
rb  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$  r(   r>   r§  r«  r)   r*   r“   ù  s   ÿz9OverrideCheckNode.analyse_expressions.<locals>.<listcomp>©r¬  rV   )Úexpr©r;   rä   )r3  rV   r(  r¿  rº   r  ÚRawCNameExprNoder(   r   Ú	func_noder­  rK  rþ   Úis_returncoderÛ   ÚExprStatNoder®  r¡   rw   )r‡   rE   Z	first_argZ	call_noder)   r«  r*   rw   ï  s(    ÿþþz%OverrideCheckNode.analyse_expressionsc                 C   s@  |  | jjj¡}| jjr$dtj }nd| jd j }| 	d¡ | 	dtj
 ¡ | 	d¡ | jjrl| 	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
¡¡ | || j¡}| 	d||||f ¡ | |¡ d| }d|| jjjf }| 	d||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 )Nrt  r   z /* Check if called by wrapper */zif (unlikely(%s)) ;z#/* Check if overridden in Python */rJ  zƒelse if (unlikely((Py_TYPE(%s)->tp_dictoffset != 0) || (Py_TYPE(%s)->tp_flags & (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PyCFunction_Check(%s)z8(PyCFunction_GET_FUNCTION(%s) != (PyCFunction)(void*)%s)zif (!%s || %s) {r  z#%s = __Pyx_get_tp_dict_version(%s);z'%s = __Pyx_get_object_dict_version(%s);zif (unlikely(%s != %s)) {z"%s = %s = __PYX_DICT_VERSION_INIT;) r-  r(  rØ   r>   r¿  r	   Úmodule_cnamerV   rF  rS   r·  rÒ   rŸ  r   r!  Ztp_dict_version_tempZobj_dict_version_tempZtype_dict_guard_temprã  rä  r   ru  Ú	set_cnameræ  r(   rç  r¹  r¡   rÔ   ré  r
   rê  )r‡   rY   Zinterned_attr_cnamer	  Zfunc_node_tempÚerrZis_builtin_function_or_methodZis_overriddenr)   r)   r*   rÔ     s‚    

ÿÿ

ÿÿ
ÿÿ

ÿÿ

ÿ

ÿÿÿÿ




z)OverrideCheckNode.generate_execution_code)rO   rr   rs   r•   r¡   rw   rÔ   r)   r)   r)   r*   r¤  á  s   
r¤  c                   @   s   e Zd ZdS )ÚClassDefNodeN©rO   rr   rs   r)   r)   r)   r*   r|  S  s   r|  c                   @   sb   e Zd Zg 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dd„ Zdd„ Zdd„ ZdS )ÚPyClassDefNode)	r¡   rh   Ú	metaclassÚmkwrm   Úclass_resultr€  Ú
class_cellrÆ  NFc	                 C   sê  t  | |¡ || _|| _|| _|| _|| _ddlm}	 | jr`t	j
r`t| j| jƒ}|	j||d}
nd }
| }|rüd}d| _|jrð|jràtt|jƒƒd d d… D ]:\}}|jjdkrœ| jd urÆt|jdƒ |j| _|j|= qœ|| _qü| jd usüJ ‚n|	 |¡| _|s| js| js| jr¤| jd u rr|r<|js<| j}nd }|s\| jjr\| jjs\n|	j|| d	| _d}nd}|	j|||
| d
| _|	j||| |
||d| _n$|	j |g d| _|	j!||| |
d| _|	j"||d| _#|	 $| j¡| _%d S )Nr   r¦  rs  FTr½   r  z2keyword argument 'metaclass' passed multiple times)Úclass_def_node)r>   r1   rƒ  )r>   rƒ  r1   Zcalculate_metaclassÚallow_py2_metaclass©r:   )r>   rƒ  r1   r¶  )&rë   r‰   r>   r1   r¡   rÆ  rm   rº   r  r   rÅ  r2   r(   Z
StringNodeÚis_py3_style_classr9   r:   r—   rC  rµ   r;   r  r   r€  Ú	ProxyNodeZis_sequence_constructorrV   ZPyClassMetaclassNodeZPyClassNamespaceNoderh   ZPy3ClassNodeÚclassobjÚDictNodeZ	ClassNoder$  r€  ZClassCellInjectorNoder‚  )r‡   r(   r>   rm   r1   r¡   rÆ  r¦  Zforce_py3_semanticsr  Zdoc_noder„  rS  r«   ZmkdictZneeds_metaclass_calculationr)   r)   r*   r‰   o  sp     

ÿþÿÿý
ÿ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´  ©rV   F)r  rW  Ú
class_namerm   rÆ  r¡   r  r1   )r†  r   rˆ  r(   rº   r  ÚCClassDefNoder>   rm   r  rÆ  r¡   r1   ©r‡   r  r)   r)   r*   Ú	as_cclassµ  s    øzPyClassDefNode.as_cclassc                 C   s0   |}|j s|jr|j}qt| j|d }| _|S )N)r>   r¾  )rû  rD  r¾  r   r>   r[  )r‡   rE   rþ  rk  r)   r)   r*   Úcreate_scopeÈ  s
    zPyClassDefNode.create_scopec                 C   s¸   | j }| jrHddlm} | jd d d… D ]}||j|j|gd}q(d | _|| _| jr`| j |¡ | j	rr| j	 |¡ | j |¡ | j
 |¡ |  |¡}|j|_| j
jj|_| j |¡ d S )Nr   )r­  r½   rq  )rˆ  rÆ  r  r­  r(   r  r  rm   rœ   r€  r€  Úanalyse_target_declarationr  rÏ   rØ   rF  Úclass_obj_cnamer¡   )r‡   rE   r  r­  r  rk  r)   r)   r*   rœ   Ï  s*    ý
z#PyClassDefNode.analyse_declarationsc                 C   sŽ   | j r| j  |¡| _ | jr(| j |¡| _| jr<| j |¡| _| j |¡| _| j |¡| _| j}| j |¡| _| j 	|| j
¡ | j |¡| _| S r‚   )rm   rw   r€  r  rh   r  r[  r¡   r€  Úanalyse_target_expressionrˆ  r‚  )r‡   rE   rk  r)   r)   r*   rw   å  s    z"PyClassDefNode.analyse_expressionsc                 C   s"   |   | j|¡ | j | j|¡ d S r‚   )rÚ   r[  r¡   rÓ   rì   r)   r)   r*   rÓ   ô  s    z,PyClassDefNode.generate_function_definitionsc                 C   s’  |  | j¡ |j | ¡ | j}| jr0| j |¡ | jrB| j |¡ | jrT| j |¡ | j	 |¡ | j	 
¡  |_|_| j}|d urŠ|jsŠd }|d urœ| |¡ | j |¡ | j |¡ |d urÎ| || j 
¡ ¡ |d urê| |¡ | |¡ | j 
¡  |_|_| j | j|¡ | j	 |¡ | j	 |¡ | jrD| j |¡ | j |¡ | jrd| j |¡ | j |¡ | jr„| j |¡ | j |¡ |j ¡  d S r‚   )rç   r(   Zpyclass_stackr&  r[  rm   rv  r€  r  rh   r™   Únamespace_cnamer‘  r‚  Ú	is_activer¡   rÔ   r  Zgenerate_injection_codeÚgenerate_disposal_coder  rˆ  r€  r‚  Úpop)r‡   rY   rk  r‚  r)   r)   r*   rÔ   ø  sN    

ÿ

z&PyClassDefNode.generate_execution_code)NNF)rO   rr   rs   r•   rÆ  r  r†  r  r€  r‰   rŽ  r  rœ   rw   rÓ   rÔ   r)   r)   r)   r*   r~  W  s     ÿ
F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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   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)rq  rº   r©  Úbuffer_defaults_noder«  Úbuffer_defaults_posr—  )r‡   rE   r©  r)   r)   r*   r¬  E  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| _d S )Nr1  Ú.r   )r>   r(   r“  ÚimplementingrW  rG   Úobjstruct_cnameÚtypeobj_cnamer  r\  Ú
check_sizerº  r¬  Úshadow)rW  r  Úsplitr‘  r(   Údeclare_c_classr‹  Úobjstruct_nameÚtypeobj_namer\  rž  rº  r¬  rŸ  rØ   )r‡   rE   r  Ú
home_scoper)   r)   r*   rË  Q  s,    òzCClassDefNode.declarec                    s  ˆ j rˆjstˆjdƒ ˆjr0tˆjdˆj ƒ d ˆ_ˆjrd ˆ_ˆ j	D ]}|j
ˆjkrH|ˆ_qHˆjd u rtˆjd ˆ jƒˆ_dˆj_ˆ  ˆj¡ ˆjjrÞˆjjd }| ˆ ¡}|tjtjtjfv rÔˆ  | ¡ ¡j}|d u rðt|jdˆj ƒ nÀ|tjkrd }n®|js,|jr|js,t|jd| ƒ n„| ¡ sPt|jd|j
ˆjf ƒ n`|jr‚|jjr‚|j r‚t|jd|ˆjf ƒ n.|jrª|j
d	v rªt|jd
|j
 ƒ n|ˆ_ˆ j !dd¡dkrÞ|tjkrÞt"ˆjddƒ ˆj#d u}|rˆjrˆjjsˆjj$ %‡ ‡fdd„¡ d S ˆjrVˆj&dkrVˆj 'd¡}ˆ  (|ˆj¡}|sZd S nˆ }ˆj&dkr¨ˆjdkr¨ˆjt)j*v r¨ˆ j+d d… dkr¨t"ˆjdˆj dƒ |j,ˆjˆj|o¾ˆj-|oÊˆj- ˆjˆjˆjˆj.ˆj/ˆj&ˆj0ˆj1ˆ 2ˆ ¡ˆj3dˆ_4ˆj3rˆj4| ˆj¡_5|ˆ ur@ˆj&dkr@ˆ  6ˆjˆj4ˆj¡ ˆj4jj ˆ_}	|	d urbˆ j|	_ˆj7r‚t8j9r‚t:ˆjˆj7ƒ|	_7|röˆj# ;|	¡ ˆj <d¡}
|
rà|
j=rà|	j>sà|	j?sàˆj @d¡|
_Aˆj Bd|
j7|
j¡ ˆj-rðd|	_>nd|	_?tCˆjjƒdkr¦|rˆj-r*tˆjjd jdƒ ˆjjdd … D ]}| ˆ ¡r:t|jdƒ q:dˆj4j_DddlEmF} |jGˆj|jHˆjˆjdˆj|jIˆjg dgdˆ_Jn8ˆjrÎˆjjKp¾ˆjjDˆj4j_Dd ˆ_Jndˆj4j_Dd ˆ_Jˆ  Lˆj4¡ ˆj4jj$D ]}|ƒ  qôd S )NzTObject struct name specification required for C class defined in 'extern from' blockz:Decorators not allowed on cdef classes (used on type '%s')r   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:  ÚstrÚ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 r‚   )rœ   r)   r?  r)   r*   Ú<lambda>¡  r”   z4CClassDefNode.analyse_declarations.<locals>.<lambda>r1  rš  Ú__builtin__é   zcpython.z %s already a builtin Cython type)r>   r(   r“  r›  rW  rG   rœ  r  rž  r  r\  rº  r¬  rŸ  r…   Z__dict__getterz'Only declare first base in declaration.z+Only one extension type base class allowed.r¦  rs  r…  rŠ  )Mrð   r¢  r   r(   rÆ  r‹  rG   rW  ÚmoduleZcimported_modulesr>   r   rn  Zhas_extern_classÚadd_imported_modulerm   rV   r<   r
   rA   r@   rB   r  Zsign_and_namer3   r   rä  rv  rœ  r  r[  rÏ   rô  rˆ  r   r¡   Zdefered_declarationsr&  r  r   r‘  r   Zbuiltin_typesr[  r¡  r  r£  rž  r\  rº  r¬  rŸ  rØ   r¡  Úadd_imported_entryr1   r   rÅ  r2   rœ   r¢  Zis_variableZdefinedZimplementedZmangle_internalZgetter_cnameÚdeclare_propertyrL   Ú
early_initrº   r  r  ZIdentifierStringNoder‰  Útype_init_argsZis_externalZallocate_vtable_names)r‡   rE   rª  r  rG   Zbase_class_scopeZhas_bodyr  r¤  r[  Z
dict_entryZ
other_baser  Zthunkr)   r?  r*   rœ   j  sô    



ÿÿ
ÿ
ÿÿ
ÿÿ 

ÿþ
ò

þþ

z"CClassDefNode.analyse_declarationsc                 C   s4   | j r| jjj}| j  |¡| _ | jr0| j |¡ | S r‚   )r¡   rØ   r3   r[  rw   r¯  rÊ  r)   r)   r*   rw   ó  s    
z!CClassDefNode.analyse_expressionsc                 C   s(   | j r$|  | j|¡ | j  | j|¡ d S r‚   )r¡   rÚ   r[  rÓ   rì   r)   r)   r*   rÓ   û  s    z+CClassDefNode.generate_function_definitionsc                 C   sZ  |  | j¡ | jr| j |¡ | jjjsV| jrF| j |¡ d| j 	¡  }d| }|j
 tjd¡}| d|| j 	¡ f ¡ | | || j¡¡ | |¡ | d||f ¡ | d¡ | d||f ¡ | | | j¡¡ | d¡ |j
 |¡ | |tj¡ | |¡ | d	| jjj|f ¡ | |tj¡ | j |¡ | j |¡ |  | j|d¡ d S )
NzPyTuple_GET_ITEM(%s, 1)z(((PyTypeObject*)PyTuple_GET_ITEM(%s, 0))Tz0%s = PyType_Type.tp_new(&PyType_Type, %s, NULL);z*if (((PyTypeObject*) %s)->tp_base != %s) {zPPyErr_Format(PyExc_TypeError, "best base '%s' must be equal to first base '%s'",zB             ((PyTypeObject*) %s)->tp_base->tp_name, %s->tp_name);r  z%s.tp_bases = %s;)rç   r(   r¡   rÔ   rØ   r3   r®  r¯  rv  r™   rã  rä  r
   r   rS   ræ  rç  rè  rê  rB  r}  r  ré  r•  r  Úgenerate_type_ready_code)r‡   rY   rm   Z
first_baseZ
trial_typer)   r)   r*   rÔ      s>    
ÿ
ÿ
ÿ

z%CClassDefNode.generate_execution_codec              
   C   s¾  | j }|j}|j}|sd S | jdkrœtjD ]}| ||¡ q,|r\|j t	 
dd¡¡ d}nd}| d||| | j¡f ¡ | d¡ | d| ¡ | d¡ t |d	¡}t |d
¡}	|dkr$|	dkr$|jrÚd}
d}nd}
d}|j t	 
|d¡¡ | d||f ¡ | d||
f ¡ | d¡ | j jjD ] }|jdv }|jr.tjr.|jr.|s.tj |j¡}|rx| ¡ nd }|rŒ| |¡ | d¡ | d¡ | d||j| d| j¡f ¡ | d¡ | d|j ¡ | d|j|jf ¡ | d|j ¡ | d¡ | d¡ | d¡ |r.| d¡ q.|jr |j t	 
dd¡¡ | d||j| | j¡f ¡ |r |j t	 
d d¡¡ | d!|| | j¡f ¡ |jjsâ|jj d"¡sâ| d#tj | !|j"¡|| | j¡f ¡ |j#sô| $d$¡nd }|rR|j t%u rFd%| }|j&r"|j'}n
d&|j' }| d'||||j(f ¡ nt)|jd(ƒ |j#sh| $d)¡rœnd rœ|j t	 
d*d¡¡ | d+|| | j¡f ¡ |jrº| d,|j*|jf ¡ d S )-Nr1  ZPyType_ReadyzExtensionTypes.cZ__Pyx_PyType_Readyzif (%s(&%s) < 0) %sz#if PY_VERSION_HEX < 0x030800B1z%s.tp_print = 0;r  Ztp_getattroZtp_dictoffsetrÇ  Z#__Pyx_PyObject_GenericGetAttrNoDictZPyObject_GenericGetAttrNoDictZ__Pyx_PyObject_GenericGetAttrZPyObject_GenericGetAttrrx  z„if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!%s.tp_dictoffset && %s.tp_getattro == PyObject_GenericGetAttr)) {z%s.tp_getattro = %s;r  r†  r  r  zEPyObject *wrapper = PyObject_GetAttrString((PyObject *)&%s, "%s"); %sÚwrapperz/if (Py_TYPE(wrapper) == &PyWrapperDescr_Type) {z0%s = *((PyWrapperDescrObject *)wrapper)->d_base;z%s.doc = %s;z0((PyWrapperDescrObject *)wrapper)->d_base = &%s;Z	SetVTableúImportExport.cz+if (__Pyx_SetVtable(%s.tp_dict, %s) < 0) %sZMergeVTablesz#if (__Pyx_MergeVtables(&%s) < 0) %sZinternalz5if (PyObject_SetAttr(%s, %s, (PyObject *)&%s) < 0) %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.if (__Pyx_setup_reduce((PyObject*)&%s) < 0) %sz	%s = &%s;)+r3   r  r[  r  r   Z
slot_tableZgenerate_dynamic_init_coderÒ   rŸ  r   r!  rS   rè  r(   Zget_slot_code_by_namerô  Zpyfunc_entriesr>   rd  r   rÅ  rù  r‡  rˆ  r‰  ræ  rø  Zvtable_cnameZvtabptr_cnameZis_internalrÏ   r	   ry  r-  r‹  Zis_closure_class_scoper¢  r   r\  rœ  rF  r   r@  )rØ   rY   Zheap_type_basesr3   r  r[  rŠ  Z	readyfuncZgetattr_slot_funcZdictoffset_slot_funcZpy_cfuncZutility_funcr_   rý   rj  Zweakref_entryZtp_weaklistoffsetZ	objstructr)   r)   r*   r°  #  s   

ÿ
ýÿ

ÿÿÿ

ÿÿ


ýÿÿÿÿÿÿÿ



ÿ
ýÿ
ÿ
þ

üÿ
ü

ÿ
þÿÿz&CClassDefNode.generate_type_ready_codec                 C   s(   | j r| j  |¡ | jr$| j |¡ d S r‚   )r¯  r¢   r¡   rž   r)   r)   r*   r¢   ¬  s    zCClassDefNode.annotate)F)rO   rr   rs   r•   r˜  r™  r\  rº  r¢  r£  rž  rÆ  rŸ  r¬  rË  rœ   rw   rÓ   rÔ   rê   r°  r¢   r)   r)   r)   r*   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 )ÚPropertyNoder¡   c                 C   s6   |  | j| j| j¡| _|j| jj_| j | jj¡ d S r‚   )	r­  r>   r1   r(   rØ   rÏ   r[  r¡   rœ   r‹   r)   r)   r*   rœ   ½  s    z!PropertyNode.analyse_declarationsc                 C   s   | j  |¡| _ | S r‚   )r¡   rw   r‹   r)   r)   r*   rw   Â  s    z PropertyNode.analyse_expressionsc                 C   s   | j  ||¡ d S r‚   )r¡   rÓ   rì   r)   r)   r*   rÓ   Æ  s    z*PropertyNode.generate_function_definitionsc                 C   s   d S r‚   r)   rž   r)   r)   r*   rÔ   É  s    z$PropertyNode.generate_execution_codec                 C   s   | j  |¡ d S r‚   ró   rž   r)   r)   r*   r¢   Ì  s    zPropertyNode.annotateN)	rO   rr   rs   r•   rœ   rw   rÓ   rÔ   r¢   r)   r)   r)   r*   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 r‚   )ÚnamesZdeclare_globalr(   ©r‡   rE   r>   r)   r)   r*   rœ   ×  s    
zGlobalNode.analyse_declarationsc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw   Û  s    zGlobalNode.analyse_expressionsc                 C   s   d S r‚   r)   rž   r)   r)   r*   rÔ   Þ  s    z"GlobalNode.generate_execution_codeNrî  r)   r)   r)   r*   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 r‚   )r¶  Zdeclare_nonlocalr(   r·  r)   r)   r*   rœ   é  s    
z!NonlocalNode.analyse_declarationsc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw   í  s    z NonlocalNode.analyse_expressionsc                 C   s   d S r‚   r)   rž   r)   r)   r*   rÔ   ð  s    z$NonlocalNode.generate_execution_codeNrî  r)   r)   r)   r*   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 )rw  rr  c           
      C   sÜ   ddl m} | j}t||jƒrž|j ¡ }|dkrØ| ¡ \}}t|ƒrPt	|j
dƒ |jD ]>\}}| |¡}	|	d u r~t	|j
dƒ qV|j|j|	|j
dd qVt| _n:t|dd ƒd urØ|jrÆ| |¡ t| _n|jsÒ|jrØt| _d S )	Nr   r¦  rË  z!Variable names must be specified.úUnknown typeT)r¼  rD   )rº   r  rr  rM   ZGeneralCallNoder¬  Úas_cython_attributeÚexplicit_args_kwdsrL   r   r(   r:   r<   r^  r;   ÚPassStatNoderN   r–   r=   Zdeclare_from_annotationÚis_attributeÚis_subscript)
r‡   rE   r  rr  r_   rV   rW   ÚvarrU  r3   r)   r)   r*   rœ   û  s(    


z!ExprStatNode.analyse_declarationsc                 C   s"   d| j _| j  |¡| _ d| j _| S r²  )rr  Úresult_is_usedrw   r‹   r)   r)   r*   rw     s    z ExprStatNode.analyse_expressionsc                 C   s   | j jjr| j jr|  ¡  d S r‚   )rr  r3   r?   Úis_temprŒ   r‹   r)   r)   r*   rÌ     s    zExprStatNode.nogil_checkzDiscarding owned Python objectc                 C   sx   |  | j¡ d| j_| j |¡ | jjs\| j ¡ r\| j ¡ }| jjjsNd| }| 	d| ¡ | j 
|¡ | j |¡ d S )NFz
(void)(%s)z%s;)rç   r(   rr  rÀ  rv  rÁ  r™   r3   rþ   rS   r•  r  )r‡   rY   r™   r)   r)   r*   rÔ   !  s    

z$ExprStatNode.generate_execution_codec                 C   s   | j  ||¡ d S r‚   )rr  rÓ   rì   r)   r)   r*   rÓ   -  s    z*ExprStatNode.generate_function_definitionsc                 C   s   | j  |¡ d S r‚   )rr  r¢   rž   r)   r)   r*   r¢   0  s    zExprStatNode.annotateN)rO   rr   rs   r•   rœ   rw   rÌ   rŠ   rÔ   rÓ   r¢   r)   r)   r)   r*   rw  ô  s   rw  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)
rv   rM   rÂ  ÚParallelAssignmentNodeÚrhsr3   rû   Zis_ephemeralr   r(   )r‡   rE   rX   r)   r)   r*   rw   =  s
    
z"AssignmentNode.analyse_expressionsc                 C   s$   |  | j¡ |  |¡ |  |¡ d S r‚   )rç   r(   Úgenerate_rhs_evaluation_coder‚  rž   r)   r)   r*   rÔ   H  s    
z&AssignmentNode.generate_execution_codeN)rO   rr   rs   rw   rÔ   r)   r)   r)   r*   rÂ  4  s   	rÂ  c                   @   st   e Zd Zddg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 )ÚSingleAssignmentNodern  rÄ  Fc                 C   s  ddl m} t| j|jƒrö| jj ¡ }|rö| j ¡ \}}|dv r¬t|ƒdkrft	|d j
dƒ d S |d ur¢| d ¡}|dksˆd|vr˜t	|j
dƒ d S |d }nd	}|d
  |¡}|d u 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v r°d| _t|ƒd
ksÔ|d u ræt	| jj
dƒ d S g }|jD ]@\}}| |¡}|d u 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 |¡ 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 r)   )r>   r(   ©r‘   r¿  r)   r)   r*   r“   |  r”   z=SingleAssignmentNode.analyse_declarations.<locals>.<listcomp>zInvalid declarationT)r¼  r  zInvalid declaration.)r  )rY  Úunionz.Struct or union members must be given by name.FZ
fused_typez*fused_type does not take keyword arguments)r>   rf   )rº   r  rM   rÄ  ZCallNoder¬  rº  r»  rL   r   r(   Úcompile_time_valuer<   rn  r$  r>   r  rV   r^  Údeclaration_onlyrµ  r:   r&  r;   r   r`  r´  rœ   r  )r‡   rE   r  Ú	func_namerV   rW   Zkwdictr  r3   rn  Úvarsr¿  r(   ÚmembersÚmemberrU  r>   r[  Z	fusednoder)   r)   r*   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jrT| | jd| jj| jjg¡}|r@| j}d| _|jj| _|jj| _| jdkrR| jd u rR| 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  r[   Ústopú=Tr/  ZCppExceptionConversionzCppSupport.cpp) rº   r  rÄ  rv   Ú
unroll_rhsrn  rx   Úgil_assignment_checkÚ
unroll_lhsrM   ZMemoryViewIndexNodeZanalyse_broadcast_operationZ$analyse_as_memview_scalar_assignmentr3   rü   ÚSliceIndexNoder(   r  Zlookup_operator_for_typesÚis_overloaded_assignmentr7  r#  rŸ  r   r!  rM  r½  r=   rÇ   r?   Úcoerce_to_tempÚcoerce_to_simple)r‡   rE   Úuse_tempr  Zunrolled_assignmentÚoprÄ  r)   r)   r*   rv   ³  sP    




ÿÿþ

z"SingleAssignmentNode.analyse_typesc              	   C   s.  ddl m}m} |}d  } } }	}
|jjr8|jj}nf|jjsJ|jjršt||j	ƒrn|j
sn|jsn|j }}qJt||j	ƒrp|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yl   t| jdƒ Y d S 0 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 ur¬|	 ¡ r˜|j|	j }|j| jt|ƒ|d}n|j| jd|	|d}|d ur| ¡ rî| ¡ rî|j|j }|j| jt|ƒ|d}n|j| jd||d}| |j| j||  |¡d¡ qB|
||fS )Nr   )r  Ú	UtilNodes)r;   rå  z*C array iteration requires known end indexc                 S   s&   | d u r|S |   ¡ r| jS tdƒ‚d S )NzNot a constant.)Úhas_constant_resultrå  r  )rX   Z
none_valuer)   r)   r*   Ú	get_const  s
    z.SingleAssignmentNode.unroll.<locals>.get_constr   z5C array assignment currently requires known endpointsz=Assignment to/from slice of wrong length, expected %s, got %s)r;   rå  r3   r5  )ÚoperatorZoperand1Zoperand2r/  )r  r  )!rº   r  rÛ  r3   Ú	is_ctupler   rû   rü   rM   rÕ  r[   rÐ  r  rM  r
   r)  ZIntNoder(   r¥  r   Zconstant_value_not_setr   r  Z
LetRefNoderÇ   r&  rÄ  rÜ  rå  ZMulNodeZAddNodeZ	IndexNoderv   )r‡   rX   Ztarget_sizerE   r  rÛ  r  Z
start_nodeZ	stop_nodeZ	step_nodeÚ
check_nodeZ
slice_sizerÝ  ri   Úrefsr  Zix_nodeZ
step_valueZindex_valuer)   r)   r*   Ú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Û  )rn  rÄ  Úfirst)r(   rÜ   r½   )rº   rÛ  r–  r&  rÆ  r(   rã  rÃ  rw   rÛ   ZLetNode)r‡   rá  rà  Úlhs_listZrhs_listrE   rÛ  Úassignmentsrn  rÄ  rX   r%  r)   r)   r*   Úunroll_assignmentsA  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 r‚   )Z
is_starredr§  r)   r)   r*   rï   Q  r”   z2SingleAssignmentNode.unroll_rhs.<locals>.<genexpr>)rº   r  rM   rn  r  ÚanyrV   râ  rÄ  rL   ræ  )r‡   rE   r  Úunrolledrà  rá  rÄ  r)   r)   r*   rÒ  M  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¦  )rn  r3   rß  rº   r  rM   rÄ  r  râ  rL   rV   ræ  )r‡   rE   r  rè  rà  rá  rn  r)   r)   r*   rÔ  Z  s    

zSingleAssignmentNode.unroll_lhsc                 C   s   | j  |¡ d S r‚   ©rÄ  rv  rž   r)   r)   r*   rÅ  h  s    z1SingleAssignmentNode.generate_rhs_evaluation_codec                 C   s:   | j r&| jj| j|| j | j| jd n| j | j|¡ d S )N)r  r7  r#  )rÖ  rn  r‚  rÄ  r7  r#  )r‡   rY   r  r)   r)   r*   r‚  k  s    ûz-SingleAssignmentNode.generate_assignment_codec                 C   s   | j  ||¡ d S r‚   ©rÄ  rÓ   rì   r)   r)   r*   rÓ   v  s    z2SingleAssignmentNode.generate_function_definitionsc                 C   s   | j  |¡ | j |¡ d S r‚   ©rn  r¢   rÄ  rž   r)   r)   r*   r¢   y  s    zSingleAssignmentNode.annotateN)r   )F)rO   rr   rs   r•   rã  rÖ  rË  rœ   rv   râ  ræ  rÒ  rÔ  rÅ  r‚  rÓ   r¢   r)   r)   r)   r*   rÆ  N  s   T
0^
rÆ  c                   @   sT   e Zd Zg d¢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 )ÚCascadedAssignmentNode)rä  rÄ  Úcoerced_valuesÚcloned_valuesNc                 C   s   | j D ]}| |¡ qd S r‚   )rä  r  )r‡   rE   rn  r)   r)   r*   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	|
vr|j	|j	kr|| j
ƒ}|st| |j	|¡}| j |¡ ||
|j	< qg | _| jD ]&}|
 |j	| j
¡}| j ||ƒ¡ qš| S )Nr   )Ú	CloneNoder‡  rÑ  )r  rð  r‡  r   rC  rä  rx   rÓ  r·   r3   rÄ  rv   rL   ÚnextÚiterr  Zlookup_operatorrM  r–  r=   rÇ   r½  r?   r×  rØ  rÁ  rî  Úassignment_overloadsr&  rï  rˆ  )r‡   rE   rÙ  rð  r‡  Z	lhs_typesrS  rn  rÄ  rÚ  rî  Z
overloadedr)   r)   r*   rv   •  sP    
ÿÿÿ



z$CascadedAssignmentNode.analyse_typesc                 C   s   | j  |¡ d S r‚   rê  rž   r)   r)   r*   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  )
rî  rv  r–  rä  rï  ró  r‚  r•  r  rÄ  )r‡   rY   r  rÄ  rn  ÚoverloadÚ	rhs_valuer)   r)   r*   r‚  É  s    



z/CascadedAssignmentNode.generate_assignment_codec                 C   s   | j  ||¡ d S r‚   rë  rì   r)   r)   r*   rÓ   Ø  s    z4CascadedAssignmentNode.generate_function_definitionsc                 C   sR   | j D ]}| |¡ qt| j| jƒD ]\}}| |¡ | |¡ q$| j |¡ d S r‚   )rî  r¢   r–  rä  rï  rÄ  )r‡   rY   rÄ  rn  r)   r)   r*   r¢   Û  s    

zCascadedAssignmentNode.annotate)r   )F)rO   rr   rs   r•   rï  rî  ró  rœ   rv   rÅ  r‚  rÓ   r¢   r)   r)   r)   r*   rí  ~  s   
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 )rÃ  rÜ   c                 C   s   | j D ]}| |¡ qd S r‚   rÞ   rß   r)   r)   r*   rœ   ô  s    
z+ParallelAssignmentNode.analyse_declarationsc                    s   ‡ fdd„| j D ƒ| _ | S )Nc                    s   g | ]}|j ˆ d d‘qS )r   )rÙ  )rv   râ   rã   r)   r*   r“   ù  s   ÿz>ParallelAssignmentNode.analyse_expressions.<locals>.<listcomp>rä   r‹   r)   rã   r*   rw   ø  s    
ÿz*ParallelAssignmentNode.analyse_expressionsc                 C   s<   |  | j¡ | jD ]}| |¡ q| jD ]}| |¡ q(d S r‚   )rç   r(   rÜ   rÅ  r‚  rè   r)   r)   r*   rÔ     s
    

z.ParallelAssignmentNode.generate_execution_codec                 C   s   | j D ]}| ||¡ qd S r‚   rå   ræ   r)   r)   r*   rÓ   
  s    
z4ParallelAssignmentNode.generate_function_definitionsc                 C   s   | j D ]}| |¡ qd S r‚   ré   rè   r)   r)   r*   r¢     s    
zParallelAssignmentNode.annotateN©	rO   rr   rs   r•   rœ   rw   rÔ   rÓ   r¢   r)   r)   r)   r*   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 )ÚInPlaceAssignmentNodern  rÄ  c                 C   s   | j  |¡ d S r‚   ©rn  r  r‹   r)   r)   r*   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v rh| j  t
j|¡| _ | S )Nz+-)rÄ  rv   rn  rx   Úis_memview_indexÚis_buffer_accessrM  r3   Ú	is_stringrÞ  r
   r)  r‹   r)   r)   r*   rv   *  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v 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ç   r(   rn  rÄ  rv  Z generate_subexpr_evaluation_coderÞ  r   rú  rù  r3   r?   r  rÒ   rÏ   Zgenerate_buffer_setitem_codeZis_memview_slicerS   r™   Zgenerate_subexpr_disposal_codeZfree_subexpr_tempsr•  r  )r‡   rY   rn  rÄ  Zc_opr)   r)   r*   rÔ   6  s,    




z-InPlaceAssignmentNode.generate_execution_codec                 C   s   | j  |¡ | j |¡ d S r‚   rì  rž   r)   r)   r*   r¢   Q  s    zInPlaceAssignmentNode.annotatec                 C   s$   ddl m} | | j| j| j| j¡S ré  )rº   r  Z
binop_noder(   rÞ  rn  rÄ  r  r)   r)   r*   Úcreate_binop_nodeU  s    z'InPlaceAssignmentNode.create_binop_nodeN)	rO   rr   rs   r•   rœ   rv   rÔ   r¢   rþ  r)   r)   r)   r*   r÷    s   r÷  c                   @   s>   e Zd ZddgZdd„ ZejZdZdd„ Z	dd	„ Z
d
d„ ZdS )ÚPrintStatNodeÚ	arg_tuplerQ   c                 C   sd   | j r| j  |¡}| |¡| _ | j |¡}| |¡| _| t¡ t| jjƒdkr`| jr`| t	¡ | S rà  )
rQ   rw   Úcoerce_to_pyobjectr   rŸ  Úprinting_utility_coderL   rV   Úappend_newlineÚprinting_one_utility_code)r‡   rE   rQ   r   r)   r)   r*   rw   c  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ç   r(   rQ   rv  Ú	py_resultrL   r   rV   r  rS   rè  r•  r  )r‡   rY   Zstream_resultrd  r)   r)   r*   rÔ   q  s>    

ýÿ

üÿz%PrintStatNode.generate_execution_codec                 C   s&   | j r| j  ||¡ | j ||¡ d S r‚   )rQ   rÓ   r   rì   r)   r)   r*   rÓ   ’  s    z+PrintStatNode.generate_function_definitionsc                 C   s"   | j r| j  |¡ | j |¡ d S r‚   )rQ   r¢   r   rž   r)   r)   r*   r¢   —  s    zPrintStatNode.annotateN©rO   rr   rs   r•   rw   r„   rŒ   rÌ   rŠ   rÔ   rÓ   r¢   r)   r)   r)   r*   rÿ  Z  s   !rÿ  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 )
ÚExecStatNoderV   c                 C   sB   t | jƒD ]&\}}| |¡}| |¡}|| j|< q
| tj¡ | S r‚   )rC  rV   rw   r  rŸ  r   Zpyexec_utility_code©r‡   rE   rS  rd  r)   r)   r*   rw   ¤  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¡ |j |¡ d S )NrÇ  r%   Trâ  z%s = __Pyx_PyExec3(%s, %s, %s);)rç   r(   rV   rv  r&  r  r:  rL   rã  rä  r
   r   rS   r•  r  ræ  rç  ré  rê  )r‡   rY   rV   rd  Ztemp_resultr)   r)   r*   rÔ   ¯  s"    

 

ÿ
z$ExecStatNode.generate_execution_codec                 C   s   | j D ]}| |¡ qd S r‚   ©rV   r¢   r{  r)   r)   r*   r¢   Á  s    
zExecStatNode.annotateN)rO   rr   rs   r•   rw   r„   rŒ   rÌ   rŠ   rÔ   r¢   r)   r)   r)   r*   r    s   r  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 )ÚDelStatNoderV   Fc                 C   s   | j D ]}| |¡ qd S r‚   )rV   r  rò  r)   r)   r*   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u 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)rC  rV   r’  r3   r?   r=   rÀ  rØ   Z
is_cglobalr   r(   rû   rG   r  rŽ   r¾  r  r   Úbytearray_typer  r)   r)   r*   rw   Ò  s    zDelStatNode.analyse_expressionsc                 C   s    | j D ]}|jjr|  ¡  qd S r‚   )rV   r3   r?   rŒ   rò  r)   r)   r*   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	u rL|j
|| jd q|jjr|jjjr| |¡ | d| ¡  ¡ | |¡ | |¡ qd S )N)Úignore_nonexistingz
delete %s;)rç   r(   rV   r3   r?   rÀ  r¾  r  r   r  Zgenerate_deletion_coder  rû   rG   r  rv  rS   r™   r•  r  r{  r)   r)   r*   rÔ   ê  s"    
ÿþþÿ

z#DelStatNode.generate_execution_codec                 C   s   | j D ]}| |¡ qd S r‚   r	  r{  r)   r)   r*   r¢   ù  s    
zDelStatNode.annotateN)rO   rr   rs   r•   r  rœ   rw   rÌ   rŠ   rÔ   r¢   r)   r)   r)   r*   r
  Æ  s   r
  c                   @   s    e Zd Zg Zdd„ Zdd„ ZdS )r¼  c                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw     s    z PassStatNode.analyse_expressionsc                 C   s   d S r‚   r)   rž   r)   r)   r*   rÔ     s    z$PassStatNode.generate_execution_codeN)rO   rr   rs   r•   rw   rÔ   r)   r)   r)   r*   r¼  þ  s   r¼  c                       s    e Zd ZdZ‡ fdd„Z‡  ZS )ÚIndirectionNodez†
    This adds an indirection so that the node can be shared and a subtree can
    be removed at any time by clearing self.stats.
    c                    s   t t| ƒj|d j|d d S )Nr   rä   )rj   r  r‰   r(   )r‡   rÜ   rq   r)   r*   r‰     s    zIndirectionNode.__init__)rO   rr   rs   r€   r‰   rt   r)   r)   rq   r*   r  
  s   r  c                   @   s$   e Zd Zg ZdZdd„ Zdd„ ZdS )ÚBreakStatNodeTc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw     s    z!BreakStatNode.analyse_expressionsc                 C   s0   |  | j¡ |js t| jdƒ n| |j¡ d S )Nzbreak statement not inside loop)rç   r(   Úbreak_labelr   rR  rž   r)   r)   r*   rÔ     s    z%BreakStatNode.generate_execution_codeN©rO   rr   rs   r•   rÈ   rw   rÔ   r)   r)   r)   r*   r    s   r  c                   @   s$   e Zd Zg ZdZdd„ Zdd„ ZdS )ÚContinueStatNodeTc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw   )  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   r(   rç   rR  rž   r)   r)   r*   rÔ   ,  s
    z(ContinueStatNode.generate_execution_codeNr  r)   r)   r)   r*   r  $  s   r  c                   @   sV   e Zd ZdgZdZdZdZdZdd„ Zdd„ Z	dZ
d	d
„ Zdd„ Zdd„ Zdd„ ZdS )r®  r;   TFc                 C   s˜   |j }|| _ |s t| jdƒ | S | j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)
rK  r   r(   r;   Úin_async_genrv   rþ   rv  rM  r?   )r‡   rE   rK  r)   r)   r*   rw   D  s&    ÿþz"ReturnStatNode.analyse_expressionsc                 C   s   | j jr|  ¡  d S r‚   )rK  r?   rŒ   r‹   r)   r)   r*   rÌ   Y  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Ä  rY   r  ZReturnWithStopIterationrY  z-%s = NULL; __Pyx_ReturnWithStopIteration(%s);rz  rh  z/PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration); r&  )&rç   r(   rK  r;   r?   rV  r	   r0  rÆ   rv  rÀ  rº   r›  Zput_acquire_memoryviewslicerÍ   r~  Úin_generatorrÒ   rŸ  r   r!  rS   r  r•  r{  r|  r  r  r*  rO  rv  Ú
put_returnru  rã  Ztemps_holding_referenceré  rR  rS  )r‡   rY   r;   r›  rF  r3   r)   r)   r*   rÔ   _  sf    

ú
ÿþ

þ


ÿ

z&ReturnStatNode.generate_execution_codec                 C   s(   | j r| d¡ | dtj|f ¡ d S )Nz%#pragma omp critical(__pyx_returning)rz  )Úin_parallelÚputln_openmprS   r	   r0  )r‡   rY   r;   r)   r)   r*   r  ™  s    
zReturnStatNode.put_returnc                 C   s   | j d ur| j  ||¡ d S r‚   )r;   rÓ   rì   r)   r)   r*   rÓ   ž  s    
z,ReturnStatNode.generate_function_definitionsc                 C   s   | j r| j  |¡ d S r‚   )r;   r¢   rž   r)   r)   r*   r¢   ¢  s    zReturnStatNode.annotateN)rO   rr   rs   r•   rÈ   r  r  r  rw   rÌ   rŠ   rÔ   r  rÓ   r¢   r)   r)   r)   r*   r®  4  s   :r®  c                   @   sB   e Zd Zg 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ÚcauseTc                 C   sö   | j r| j  |¡}| |¡| _ | jr<| j |¡}| |¡| _| jrZ| j |¡}| |¡| _| jrx| j |¡}| |¡| _d | _| j rò| jsò| jsò| j }ddlm} t	||j
ƒrÌ|jsÌ|jd urÆ|jjsÌ|j}|jrò|jjrò|j| _| jdkròd | _ | S )Nr   r¦  ÚMemoryError)r  rv   r  r  r  r  Úbuiltin_exc_namerº   r  rM   r­  rV   r   r¬  r=   rØ   Ú
is_builtinr>   )r‡   rE   r  r  r  r  Úexcr  r)   r)   r*   rw   ²  s:    ÿÿÿ
z!RaiseStatNode.analyse_expressionsúRaising exceptionc                 C   s>  |  | j¡ | jdkr0| d| | j¡ ¡ d S | jrf| j |¡ | j ¡ }| jjrj|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 ] }|r| |¡ | |¡ q| | | j¡¡ d S )Nr  zPyErr_NoMemory(); %srÇ  z__Pyx_Raise(%s, %s, %s, %s);)rç   r(   r  rS   rè  r  rv  r  r=   rÒ   Zuse_entry_utility_coderØ   r  r  r  rŸ  Úraise_utility_coder•  r  )r‡   rY   Z	type_codeZ
value_codeZtb_codeZ
cause_coder|  r)   r)   r*   rÔ   Ð  sL    

üÿ

ÿz%RaiseStatNode.generate_execution_codec                 C   sd   | j d ur| j  ||¡ | jd ur0| j ||¡ | jd urH| j ||¡ | jd ur`| j ||¡ d S r‚   )r  rÓ   r  r  r  rì   r)   r)   r*   rÓ   ú  s    



z+RaiseStatNode.generate_function_definitionsc                 C   sL   | j r| j  |¡ | jr$| j |¡ | jr6| j |¡ | jrH| j |¡ d S r‚   )r  r¢   r  r  r  rž   r)   r)   r*   r¢     s    zRaiseStatNode.annotateN)rO   rr   rs   r•   rÈ   rw   r„   rŒ   rÌ   rŠ   rÔ   rÓ   r¢   r)   r)   r)   r*   r  §  s   *
r  c                   @   s.   e Zd Zg ZdZdd„ ZejZdZ	dd„ Z
dS )ÚReraiseStatNodeTc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw     s    z#ReraiseStatNode.analyse_expressionsr!  c                 C   sÂ   |  | j¡ |jj}|r”|j t¡ | |d ¡ | |d ¡ | |d ¡ | 	dt
|ƒ ¡ |D ]}| d| ¡ qd| 	¡  | 	| | 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ç   r(   rã  Úexc_varsrÒ   rŸ  rW  r}  rb  rS   r:  r*  rè  r   r!  )r‡   rY   rÍ  Úvarnamer)   r)   r*   rÔ     s     
ÿz'ReraiseStatNode.generate_execution_codeN)rO   rr   rs   r•   rÈ   rw   r„   rŒ   rÌ   rŠ   rÔ   r)   r)   r)   r*   r#    s   r#  c                   @   s>   e Zd ZddgZdd„ ZejZdZdd„ Z	dd	„ Z
d
d„ ZdS )ÚAssertStatNoderq  r;   c                 C   sz   | j  |¡| _ | jrv| j |¡}|jtju s4|jjsjddlm	} ||j
|gdd}|j|dd |¡| _n| |¡| _| S )Nr   r  T)rV   Zslow)Zskip_children)rq  Zanalyse_boolean_expressionr;   rv   r3   r   Z
tuple_typerv  r  r  r(   r  )r‡   rE   r;   r  r)   r)   r*   rw   5  s    z"AssertStatNode.analyse_expressionsr!  c                 C   sÖ   |  d¡ |  d¡ | | j¡ | j |¡ |  d| j ¡  ¡ | jr€| j |¡ |  d| j ¡  ¡ | j |¡ | j 	|¡ n
|  d¡ |  | 
| j¡¡ |  d¡ | j |¡ | j 	|¡ |  d¡ |  d¡ d S )Nz!#ifndef CYTHON_WITHOUT_ASSERTIONSz!if (unlikely(!Py_OptimizeFlag)) {r  z*PyErr_SetObject(PyExc_AssertionError, %s);z$PyErr_SetNone(PyExc_AssertionError);r  r  )rS   rç   r(   rq  rv  r™   r;   r  r•  r  rè  rž   r)   r)   r*   rÔ   E  s:    

ÿÿÿ
ÿÿÿz&AssertStatNode.generate_execution_codec                 C   s*   | j  ||¡ | jd ur&| j ||¡ d S r‚   )rq  rÓ   r;   rì   r)   r)   r*   rÓ   _  s    
z,AssertStatNode.generate_function_definitionsc                 C   s"   | j  |¡ | jr| j |¡ d S r‚   )rq  r¢   r;   rž   r)   r)   r*   r¢   d  s    zAssertStatNode.annotateNr  r)   r)   r)   r*   r(  -  s   r(  c                   @   sF   e Zd ZddgZdd„ Zdd„ Zdd„ Zd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 r‚   )r*  rœ   r+  )r‡   rE   Ú	if_clauser)   r)   r*   rœ   r  s    
zIfStatNode.analyse_declarationsc                    s.   ‡ fdd„| j D ƒ| _ | jr*| j ˆ ¡| _| S )Nc                    s   g | ]}|  ˆ ¡‘qS r)   rá   )r‘   r,  rã   r)   r*   r“   y  r”   z2IfStatNode.analyse_expressions.<locals>.<listcomp>)r*  r+  rw   r‹   r)   rã   r*   rw   x  s    zIfStatNode.analyse_expressionsc                 C   s¾   |  | j¡ | ¡ }t| jƒ}| jr>| j| jd | jdd n|d8 }t| jƒD ]*\}}|  ||j¡ |j	||||kd qP| jr°|  | jj¡ | 
d¡ | j 	|¡ | 
d¡ | |¡ d S )Nr½   T)Úinverser   )Úis_lastú
/*else*/ {r  )rç   r(   r#  rL   r*  r+  Ú_set_branch_hintrC  r¡   rÔ   rS   rT  )r‡   rY   r   ÚlastrS  r,  r)   r)   r*   rÔ   ~  s    


z"IfStatNode.generate_execution_codeFc                 C   s„   |j s
d S t|tƒr|jsd S t|jd ttfƒr€t|jƒdkrrttt	t
tf}|jd d… D ]}t||ƒs\ d S q\|rzdnd|_d S )Nr½   r   r.  r^  )rÈ   rM   rÛ   rÜ   r  r#  rL   rw  rÂ  r
  rµ  r¸  Úbranch_hint)r‡   ÚclauseZstatements_noder-  Znon_branch_nodesrX   r)   r)   r*   r0  ‘  s    
zIfStatNode._set_branch_hintc                 C   s4   | j D ]}| ||¡ q| jd ur0| j ||¡ d S r‚   )r*  rÓ   r+  )r‡   rE   rY   r3  r)   r)   r*   rÓ      s    

z(IfStatNode.generate_function_definitionsc                 C   s,   | j D ]}| |¡ q| jr(| j |¡ d S r‚   )r*  r¢   r+  )r‡   rY   r,  r)   r)   r*   r¢   ¦  s    
zIfStatNode.annotateN)F)
rO   rr   rs   r•   rœ   rw   rÔ   r0  rÓ   r¢   r)   r)   r)   r*   r)  j  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 )ÚIfClauseNodeÚ	conditionr¡   Nc                 C   s   | j  |¡ d S r‚   )r¡   rœ   r‹   r)   r)   r*   rœ   ¶  s    z!IfClauseNode.analyse_declarationsc                 C   s    | j  |¡| _ | j |¡| _| S r‚   )r5  Úanalyse_temp_boolean_expressionr¡   rw   r‹   r)   r)   r*   rw   ¹  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)r  Fr  r  )r5  rv  rç   r(   r™   r2  rS   r•  r  r¡   rÔ   rÈ   rR  )r‡   rY   r   r.  r5  r)   r)   r*   rÔ   ¾  s    

z$IfClauseNode.generate_execution_codec                 C   s    | j  ||¡ | j ||¡ d S r‚   )r5  rÓ   r¡   rì   r)   r)   r*   rÓ   Í  s    z*IfClauseNode.generate_function_definitionsc                 C   s   | j  |¡ | j |¡ d S r‚   )r5  r¢   r¡   rž   r)   r)   r*   r¢   Ñ  s    zIfClauseNode.annotate)
rO   rr   rs   r•   r2  rœ   rw   rÔ   rÓ   r¢   r)   r)   r)   r*   r4  ­  s   r4  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 r‚   )r8  rv  ©r‡   rY   rq  r)   r)   r*   Ú"generate_condition_evaluation_codeÞ  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:r4  Fr  r6  )rL   r8  rÒ   rÏ   rC  rS   r™   rç   r(   r¡   rÔ   )r‡   rY   Znum_conditionsZline_tracing_enabledrS  rq  r)   r)   r*   rÔ   â  s    
z&SwitchCaseNode.generate_execution_codec                 C   s*   | j D ]}| ||¡ q| j ||¡ d S r‚   )r8  rÓ   r¡   )r‡   rE   rY   rq  r)   r)   r*   rÓ   ï  s    
z,SwitchCaseNode.generate_function_definitionsc                 C   s&   | j D ]}| |¡ q| j |¡ d S r‚   )r8  r¢   r¡   r9  r)   r)   r*   r¢   ô  s    
zSwitchCaseNode.annotateN)rO   rr   rs   r•   r:  rÔ   rÓ   r¢   r)   r)   r)   r*   r7  Ö  s
   r7  c                   @   s,   e Zd Zg d¢Zdd„ Zdd„ Zdd„ ZdS )	ÚSwitchStatNode)ÚtestÚcasesr+  c                 C   s´   | j  |¡ | jD ]}| |¡ q| | j¡ | d| j  ¡  ¡ | jD ]}| |¡ qH| j	d ur„| d¡ | j	 |¡ | d¡ n
| d¡ | d¡ | j  
|¡ | j  |¡ d S )Núswitch (%s) {r3  r6  zdefault: break;r  )r<  rv  r=  r:  rç   r(   rS   r™   rÔ   r+  r•  r  ©r‡   rY   Úcaser)   r)   r*   rÔ     s    





z&SwitchStatNode.generate_execution_codec                 C   sB   | j  ||¡ | jD ]}| ||¡ q| jd ur>| j ||¡ d S r‚   )r<  rÓ   r=  r+  )r‡   rE   rY   r@  r)   r)   r*   rÓ     s
    

z,SwitchStatNode.generate_function_definitionsc                 C   s<   | j  |¡ | jD ]}| |¡ q| jd ur8| j |¡ d S r‚   )r<  r¢   r=  r+  r?  r)   r)   r*   r¢   !  s
    

zSwitchStatNode.annotateN)rO   rr   rs   r•   rÔ   rÓ   r¢   r)   r)   r)   r*   r;  ú  s   r;  c                   @   s   e Zd ZdS )ÚLoopNodeNr}  r)   r)   r)   r*   rA  )  s   rA  c                   @   s<   e Zd Zg d¢Zdd„ Zdd„ Zdd„ Zdd	„ Zd
d„ ZdS )ÚWhileStatNode)r5  r¡   r+  c                 C   s"   | j  |¡ | jr| j |¡ d S r‚   )r¡   rœ   r+  r‹   r)   r)   r*   rœ   6  s    z"WhileStatNode.analyse_declarationsc                 C   s:   | j r| j  |¡| _ | j |¡| _| jr6| j |¡| _| S r‚   )r5  r6  r¡   rw   r+  r‹   r)   r)   r*   rw   ;  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;r  r/  )rç   r(   Únew_loop_labelsrS   r5  rv  r•  r™   r  r¡   rÔ   rT  r  r  Úset_loop_labelsr+  )r‡   rY   Úold_loop_labelsr  r)   r)   r*   rÔ   C  s.    ÿÿ



z%WhileStatNode.generate_execution_codec                 C   s>   | j r| j  ||¡ | j ||¡ | jd ur:| j ||¡ d S r‚   )r5  rÓ   r¡   r+  rì   r)   r)   r*   rÓ   Z  s
    
z+WhileStatNode.generate_function_definitionsc                 C   s4   | j r| j  |¡ | j |¡ | jr0| j |¡ d S r‚   )r5  r¢   r¡   r+  rž   r)   r)   r*   r¢   a  s
    zWhileStatNode.annotateNrö  r)   r)   r)   r*   rB  -  s   rB  c                   @   sL   e Zd Zg d¢Zd ZZd ZZd ZZ	dd„ Z
dd„ Zdd„ Zd	d
„ ZdS )ÚDictIterationNextNode)
Údict_objÚexpected_sizeÚpos_index_varÚcoerced_key_varÚcoerced_value_varÚcoerced_tuple_varÚ
key_targetÚvalue_targetÚtuple_targetÚis_dict_flagNc                 C   s(   t j| |j|||||||dtjd d S )NT)	rG  rH  rI  rM  rN  rO  rP  rÁ  r3   ©r„   r‰   r(   r
   Zc_bint_type)r‡   rG  rH  rI  rM  rN  rO  rP  r)   r)   r*   r‰   u  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  rG  rv   rH  rI  rM  rx   ÚTempNoder(   r
   r   Úkey_refrM  r3   rJ  rN  Ú	value_refrK  rO  Ú	tuple_refrL  rP  ©r‡   rE   r  r)   r)   r*   rw   ƒ  s&    z)DictIterationNextNode.analyse_expressionsc                 C   s   | j  ||¡ d S r‚   )rG  rÓ   rì   r)   r)   r*   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 u 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 ]\}}}| |¡ qH|D ]"\}}}| ||¡ |  |¡ qdd S )NZ	dict_iterú
Optimize.crÈ  r,  Fz7%s = __Pyx_dict_iter_next(%s, %s, &%s, %s, %s, %s, %s);r   r   r#   úif (unlikely(%s == 0)) break;ú%s == -1)!rÒ   rŸ  r   r!  rG  rv  rT  rJ  rM  rU  rK  rN  rV  rL  rO  r&  Úallocater™   rã  rä  r
   rA   rS   r  rH  rI  rP  Úerror_goto_ifr(   rê  rç  r‚  Úrelease)	r‡   rY   rå  Ztemp_addressesr¿  r™   r€  ÚaddrÚresult_tempr)   r)   r*   rÔ   ›  sF    þ
ø
z-DictIterationNextNode.generate_execution_code)rO   rr   rs   r•   rJ  rT  rK  rU  rL  rV  r‰   rw   rÓ   rÔ   r)   r)   r)   r*   rF  i  s   rF  c                   @   s<   e Zd Zg d¢Zd ZZdd„ Zdd„ Zdd„ Zd	d
„ Z	dS )ÚSetIterationNextNode)Úset_objrH  rI  rK  rN  Úis_set_flagNc                 C   s$   t j| |j|||||dtjd	 d S )NT)ra  rH  rI  rN  rb  rÁ  r3   rQ  )r‡   ra  rH  rI  rN  rb  r)   r)   r*   r‰   Í  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 rR  )rº   r  ra  rv   rH  rI  rN  rx   rS  r(   r
   r   rU  rM  r3   rK  rb  rW  r)   r)   r*   rw   Ø  s    z(SetIterationNextNode.analyse_expressionsc                 C   s   | j  ||¡ d S r‚   )ra  rÓ   rì   r)   r)   r*   rÓ   ã  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_iterrX  Fz/%s = __Pyx_set_iter_next(%s, %s, &%s, &%s, %s);rY  rZ  )rÒ   rŸ  r   r!  ra  rv  rU  r[  rã  rä  r
   rA   rS   r  rH  r™   rI  rb  r\  r(   rê  rç  rK  rN  r‚  r]  )r‡   rY   rU  r_  r)   r)   r*   rÔ   æ  s(    
úz,SetIterationNextNode.generate_execution_code)
rO   rr   rs   r•   rK  rU  r‰   rw   rÓ   rÔ   r)   r)   r)   r*   r`  Å  s   r`  c                 K   sH   d|v r4|d j r"t| fi |¤ŽS t| fi |¤ŽS nt| fi |¤ŽS d S )NÚiterator)Úis_asyncÚAsyncForStatNodeÚForInStatNodeÚForFromStatNode)r(   rˆ   r)   r)   r*   ÚForStatNode  s
    
rh  c                   @   sL   e Zd Zg d¢ZdZdZdd„ Zdd„ Zdd	„ Zd
d„ Z	dd„ Z
dd„ ZdS )Ú_ForInStatNode)r€  r«   rc  r¡   r+  NFc                 C   s   t dƒ‚d S )Nz!must be implemented by subclasses)ÚNotImplementedErrorr   r)   r)   r*   Ú_create_item_node  s    z _ForInStatNode._create_item_nodec                 C   s6   | j  |¡ | j |¡ | jr*| j |¡ |  ¡  d S r‚   )r€  r  r¡   rœ   r+  rk  r‹   r)   r)   r*   rœ     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 r‚   )r€  rx   rc  rw   rk  r«   rd  r3   rû   rü   rN  rM  r¡   r+  r‹   r)   r)   r*   rw   #  s"    ÿÿþz"_ForInStatNode.analyse_expressionsc                 C   sL  |  | j¡ | ¡ }| j |¡ | d¡ | j |¡ | j | j|¡ | j	 
|¡ |  | j¡ | |j¡ | d¡ |j}| |¡ | jr|j}| d¡|_| d¡ | j 
|¡ | d¡ | |j¡r| |¡ |  | j¡ | |j¡ | j |¡ | |¡ | |¡ |  | j¡ | |¡r0| |¡ | j |¡ | j |¡ d S )Nz
for (;;) {r  Zouter_continuer/  )rç   r(   rC  rc  rv  rS   r«   r€  r‚  r¡   rÔ   rT  r  r  rD  r+  r#  r  rR  r•  r  )r‡   rY   rE  r  Zorig_continue_labelr)   r)   r*   rÔ   4  s<    








z&_ForInStatNode.generate_execution_codec                 C   sF   | j  ||¡ | j ||¡ | j ||¡ | jd urB| j ||¡ d S r‚   )r€  rÓ   rc  r¡   r+  rì   r)   r)   r*   rÓ   \  s
    
z,_ForInStatNode.generate_function_definitionsc                 C   sF   | j  |¡ | j |¡ | j |¡ | jr6| j |¡ | j |¡ d S r‚   )r€  r¢   rc  r¡   r+  r«   rž   r)   r)   r*   r¢   c  s    z_ForInStatNode.annotate)rO   rr   rs   r•   r«   rd  rk  rœ   rw   rÔ   rÓ   r¢   r)   r)   r)   r*   ri    s   
(ri  c                   @   s   e Zd ZdZdd„ ZdS )rf  Fc                 C   s   ddl m} || jƒ| _d S )Nr   )ÚNextNode)r  rl  rc  r«   )r‡   rl  r)   r)   r*   rk  q  s    zForInStatNode._create_item_nodeN)rO   rr   rs   rd  rk  r)   r)   r)   r*   rf  l  s   rf  c                   @   s    e Zd ZdZdd„ Zdd„ ZdS )re  Tc                 K   sH   d|vsJ ‚ddl m} |j|d jd d|d< tj| |fi |¤Ž d S )Nr«   r   r¦  rc  )rd  )rº   r  ZAwaitIterNextExprNoder(   ri  r‰   )r‡   r(   rˆ   r  r)   r)   r*   r‰   ~  s    zAsyncForStatNode.__init__c                 C   s    ddl m} | | j¡| j_d S ré  )rº   r  ZAsyncNextNoderc  r«   rd  r  r)   r)   r*   rk  …  s    z"AsyncForStatNode._create_item_nodeN)rO   rr   rs   rd  r‰   rk  r)   r)   r)   r*   re  v  s   re  c                   @   sn   e Zd Zg d¢ZdZdZdZdZdZdd„ Z	dd„ Z
d	d
„ Zdd„ Zdd„ ZdddddœZdd„ Zdd„ ZdS )rg  )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 r‚   )r€  rm  rn  r3   r?   rŒ   )r‡   rE   r’   r)   r)   r*   rÌ   ¥  s    zForFromStatNode.nogil_checkc                 C   s.   | j  |¡ | j |¡ | jr*| j |¡ d S r‚   )r€  r  r¡   rœ   r+  r‹   r)   r)   r*   rœ   ª  s    z$ForFromStatNode.analyse_declarationsc                 C   s¾   ddl m} | j |¡| _| j |¡| _| j |¡| _| jd u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€  rx   rm  rv   rn  ro  rM   ZUnaryMinusNoder   r(   Úset_up_loopr3   r?   r“  r   r¡   rw   r+  )r‡   rE   r  ro  r)   r)   r*   rw   °  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 urž| jjjsžt	 || jj¡}| j ||¡| _| j ||¡| _| jjsÔ| j |¡| _| jd u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€  r3   r“  Úis_enumr   r(   r?   r
   r@   rA   rm  Úwidest_numeric_typern  ro  rM  rÇ   r×  Úis_py_targetrM   ZBufferIndexNoder   Úloopvar_nodeÚpy_loopvar_noderS  rð  r  )r‡   rE   r  ro  Z	loop_typeZc_loopvar_noder)   r)   r*   rp  Å  sB    ÿ


zForFromStatNode.set_up_loopc                 C   s  |  | j¡ | ¡ }| j}| j |¡ | j |¡ | j| j \}}| j	d u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 u rš|rš| | jj||	¡}
|
d u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|¡ |rB| jsB|j 8|	¡ |j9}| :|¡ | j;rz| d¡ | j; !|¡ | d¡ | "|¡ | j <|¡ | j =|¡ | j <|¡ | j =|¡ t| j|jƒrÐ| j 7|¡ t| j|jƒrì| j 7|¡ | j	d ur| j	 <|¡ | j	 =|¡ d S )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GetModuleGlobalNamerx  z%__Pyx_GetModuleGlobalName(%s, %s); %sZGetNameInClassz$__Pyx_GetNameInClass(%s, {}, %s); %sr  r/  )>rç   r(   rC  Ú
from_rangerm  rv  rn  Úrelation_tableZ	relation1ro  r™   rº   r  rM   rt  rS  r[  ru  r€  r3   rq  r
   r@   rs  rã  rä  r  rŽ  Z	relation2rS   rt  r‚  r¡   rÔ   rT  r  rØ   Zis_pyglobalZ
PyTempNoder-  r>   r[  r¿  rÒ   rŸ  r   r!  Úformatr“  ræ  rç  ZCoerceFromPyTypeNodeZ	temp_codeÚgenerate_result_codera  r]  rê  r  rD  r+  r•  r  )r‡   rY   rE  rx  ÚoffsetZincopro  r  Zloopvar_typeZloopvar_nameZcoerced_loopvar_nodeZtarget_nodeZinterned_cnameZlookup_funcZfrom_py_noder  r)   r)   r*   rÔ   ë  sÀ    



 ü

ü



ÿ
ÿ
ÿýÿ






z'ForFromStatNode.generate_execution_code)rº   ú++)z+1r}  )rº   ú--)z-1r~  )z<=r/  z>=rw  c                 C   sl   | j  ||¡ | j ||¡ | j ||¡ | jd urB| j ||¡ | j ||¡ | jd urh| j ||¡ d S r‚   )r€  rÓ   rm  rn  ro  r¡   r+  rì   r)   r)   r*   rÓ   d  s    

z-ForFromStatNode.generate_function_definitionsc                 C   sX   | j  |¡ | j |¡ | j |¡ | jr6| j |¡ | j |¡ | jrT| j |¡ d S r‚   )r€  r¢   rm  rn  ro  r¡   r+  rž   r)   r)   r*   r¢   n  s    zForFromStatNode.annotate)rO   rr   rs   r•   rs  rt  ru  rx  rŠ   rÌ   rœ   rw   rp  rÔ   ry  rÓ   r¢   r)   r)   r)   r*   rg  Š  s$   &sû
rg  c                   @   s@   e Zd ZdZg d¢ZdZdZdd„ Zdd„ Zdd	„ Z	d
d„ Z
dS )ÚWithStatNodea  
    Represents a Python with statement.

    Implemented by the WithTransform as follows:

        MGR = EXPR
        EXIT = MGR.__exit__
        VALUE = MGR.__enter__()
        EXC = True
        try:
            try:
                TARGET = VALUE  # optional
                BODY
            except:
                EXC = False
                if not EXIT(*EXCINFO):
                    raise
        finally:
            if EXC:
                EXIT(None, None, None)
            MGR = EXIT = VALUE = None
    )ÚmanagerÚ
enter_callr€  r¡   Nc                 C   s(   | j  |¡ | j |¡ | j |¡ d S r‚   )r€  rœ   r  r¡   r‹   r)   r)   r*   rœ   ›  s    z!WithStatNode.analyse_declarationsc                 C   sT   | j  |¡| _ | j |¡| _| jrBddlm} || jj| jjƒ| _| j	 
|¡| _	| S )Nr   )rS  )r€  rv   r  r€  r  rS  r(   r3   Útarget_tempr¡   rw   )r‡   rE   rS  r)   r)   r*   rw      s    z WithStatNode.analyse_expressionsc                 C   s.   | j  ||¡ | j ||¡ | j ||¡ d S r‚   )r€  rÓ   r  r¡   rì   r)   r)   r*   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¡ | ¡ }|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PyObjectLookupSpecialrx  z-%s = __Pyx_PyObject_LookupSpecial(%s, %s); %sÚ	__aexit__Ú__exit__rz  r  )&rç   r(   rS   r€  rv  rã  rä  r   Zexit_varrÒ   rŸ  r   r!  r  r-  r   rd  ræ  rç  r  rP  r  r€  r‚  r[  r{  r™   r~  r•  r  r¡   rÔ   r  r#  rR  rT  ré  rê  )r‡   rY   r  Zintermediate_error_labelZstep_over_labelr)   r)   r*   rÔ   ¯  sJ    

ÿü



z$WithStatNode.generate_execution_code)rO   rr   rs   r€   r•   r  r‚  rœ   rw   rÓ   rÔ   r)   r)   r)   r*   r  y  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Ä  rn  Nc                 C   s   | j  |¡ d S r‚   rø  r‹   r)   r)   r*   rœ   î  s    z1WithTargetAssignmentStatNode.analyse_declarationsc                 C   s4   | j  |¡| _ | j  |¡ | jj | j j|¡| _| S r‚   )rn  rx   rÓ  Ú	with_noder‚  rM  r3   rÄ  r‹   r)   r)   r*   rw   ñ  s    z0WithTargetAssignmentStatNode.analyse_expressionsc                 C   s.   | j  |¡ | j | j |¡ | jj |¡ d S r‚   )rÄ  rv  rn  r‚  r†  r‚  r]  rž   r)   r)   r*   rÔ   ÷  s    z4WithTargetAssignmentStatNode.generate_execution_codec                 C   s   | j  |¡ | j |¡ d S r‚   rì  rž   r)   r)   r*   r¢   ü  s    z%WithTargetAssignmentStatNode.annotate)
rO   rr   rs   r•   r†  rÄ  rœ   rw   rÔ   r¢   r)   r)   r)   r*   r…  à  s   
r…  c                   @   sJ   e Zd Zg d¢ZdZdd„ Zdd„ ZejZ	dZ
dd	„ Zd
d„ Zdd„ ZdS )ÚTryExceptStatNode)r¡   Úexcept_clausesr+  Fc                 C   s8   | j  |¡ | jD ]}| |¡ q| jr4| j |¡ d S r‚   )r¡   rœ   rˆ  r+  )r‡   rE   Úexcept_clauser)   r)   r*   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¡   rw   rC  rˆ  r   r(   ÚpatternÚhas_default_clauser+  )r‡   rE   Zdefault_clause_seenrS  r‰  r)   r)   r*   rw     s    z%TryExceptStatNode.analyse_expressionszTry-except statementc                    s¤  ˆ   | 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 ¡ }ˆ  |¡}|rrˆ j t¡ | js.| d¡ | d¡ | dd dd
„ ˆD ƒ¡ ¡ ˆD ]}| |¡ 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 ]\}}ˆ  ||¡ q0ˆ jj}| ˆ j_| jD ]}| ˆ |¡ q^|ˆ j_| jsŒˆ  |¡ ||f||f||f|
|f|	|ffD ]b\}}ˆ  |¡r®|sÞˆ  |¡sÞˆ  |¡ ˆ  |¡ ˆ j | jdd |r|ƒ  ˆ  |¡ q®ˆ  |¡rP|s:ˆ  |¡s:ˆ  |¡ ˆ  |¡ |rP|ƒ  ˆ  |¡rfˆ  |¡ ˆ  d¡ ˆD ]}ˆ j  |¡ qt|ˆ _|ˆ _|ˆ _|ˆ _d S )Nr  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±  r  r)   r*   r“   4  s   ÿz=TryExceptStatNode.generate_execution_code.<locals>.<listcomp>r%   ú
/*try:*/ {Fr  r  r  r  z__Pyx_ExceptionSave(%s);rª   c                 S   s   g | ]}d | ‘qS r+  r)   rÈ  r)   r)   r*   r“   J  r”   c                     s,   ˆD ]} ˆ   | ¡ qˆ  dd ˆ¡ ¡ d S )Nz__Pyx_ExceptionReset(%s);rª   )rb  rS   r¯   r¶  ©rY   Zexc_save_varsr)   r*   Úrestore_saved_exceptionN  s
    ÿzJTryExceptStatNode.generate_execution_code.<locals>.restore_saved_exceptionc                 S   s   g | ]}d | ‘qS )z	(void)%s;r)   rÈ  r)   r)   r*   r“   V  r”   z%s /* mark used */rJ   c                   S   s   d S r‚   r)   r)   r)   r)   r*   r  Y  s    z/*else:*/ {)!rç   r(   rS   rS  r  r  r  rP  r#  rÄ  r1  r¡   rÔ   rã  Úall_free_managed_tempsr  rÒ   rŸ  Úreset_exception_utility_coder  r¯   Úput_xgotrefrÈ   r+  r(  r   rR  rT  Zcurrent_exceptrˆ  Úgenerate_handling_coder‹  rê  )r‡   rY   Úold_return_labelÚold_break_labelÚold_continue_labelr  r  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‰  Z
exit_labelÚ	old_labelrF  r)   r  r*   rÔ   #  sÎ    






ÿÿÿ



ÿÿÿ



ü





z)TryExceptStatNode.generate_execution_codec                 C   sB   | j  ||¡ | jD ]}| ||¡ q| jd ur>| j ||¡ d S r‚   )r¡   rÓ   rˆ  r+  )r‡   rE   rY   r‰  r)   r)   r*   rÓ   œ  s
    

z/TryExceptStatNode.generate_function_definitionsc                 C   s8   | j  |¡ | jD ]}| |¡ q| jr4| j |¡ d S r‚   )r¡   r¢   rˆ  r+  )r‡   rY   Zexcept_noder)   r)   r*   r¢   £  s
    
zTryExceptStatNode.annotateN)rO   rr   rs   r•   r  rœ   rw   r„   rŒ   rÌ   rŠ   rÔ   rÓ   r¢   r)   r)   r)   r*   r‡    s   yr‡  c                   @   sH   e Zd Zg d¢ZdZdZdZdd„ Zdd„ Zdd	„ Z	d
d„ Z
dd„ ZdS )ÚExceptClauseNode)rŠ  r€  r¡   r  NFc                 C   s"   | j r| j  |¡ | j |¡ d S r‚   )r€  r  r¡   rœ   r‹   r)   r)   r*   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 ré  )r[  Úfunction_namerŠ  rC  rw   r  r€  rº   r  ZExcValueNoder(   r  r’  r¡   )r‡   rE   rS  rŠ  r  r)   r)   r*   rw   Ç  s    
z$ExceptClauseNode.analyse_expressionsc                    s¼  ˆ   | j¡ | jr†tdd„ | jD ƒƒ }|rŒ‡ fdd„tdƒD ƒ}ˆ j t dd¡¡ ˆ  	dt
|ƒ ¡ ˆ j t d	d
¡¡ d|d  }nd}ˆ j t dd¡¡ d}g }| jD ] }| ˆ ¡ | || ¡  ¡ q²ˆ jjtjdd}ˆ  	d|d |¡f ¡ | jD ]}| ˆ ¡ | ˆ ¡ q|rjˆ  	dt
|ƒ ¡ ˆ  	d dd„ |D ƒ¡¡ |D ]}	ˆ j |	¡ qVˆ  	d| ¡ ˆ j |¡ n
ˆ  	d¡ t| jddƒsî| jd u rî| jd u rîˆ j t dd¡¡ ˆ  	d¡ ˆ  |¡ ˆ  	d¡ d S ‡ fdd„tdƒD ƒ}ˆ  | j¡ ˆ j t¡ dt
|ƒ }
ˆ  	d|
ˆ  | j¡f ¡ |D ]}ˆ  |¡ qF| jrŒ| j  !|d  ¡ | j  ˆ ¡ | j "| j ˆ ¡ | jd ur¼t#|| jj$ƒD ]\}}| !|¡ q¦ˆ j%ˆ j& }}ˆ  'd!¡ˆ _%ˆ  'd"¡ˆ _&ˆ jj(}|ˆ j_(| j )ˆ ¡ |ˆ j_(| jj*s2|D ]}ˆ  +|t,¡ qˆ  |¡ ˆ j%|fˆ j&|ffD ]B\}}ˆ  -|¡rFˆ  .|¡ |D ]}ˆ  /|t,¡ qhˆ  |¡ qF|ˆ _%|ˆ _&|D ]}	ˆ j |	¡ qšˆ  	d¡ d S )#Nc                 s   s$   | ]}|j p| ¡ o|j V  qd S r‚   )rÇ   Ú	is_simplerÁ  )r‘   rŠ  r)   r)   r*   rï   Û  s   ÿz:ExceptClauseNode.generate_handling_code.<locals>.<genexpr>c                    s   g | ]}ˆ j jtd d‘qS ©Trâ  rŒ  r  r  r)   r*   r“   á  s   ÿz;ExceptClauseNode.generate_handling_code.<locals>.<listcomp>r%   ÚPyErrFetchRestorer%  z__Pyx_ErrFetch(&%s, &%s, &%s);ZFastTypeChecksúModuleSetupCode.cz*__Pyx_PyErr_GivenExceptionMatches(%s, %%s)r   r)   ZPyErrExceptionMatchesz __Pyx_PyErr_ExceptionMatches(%s)Frâ  rz  z || ú__Pyx_ErrRestore(%s, %s, %s);rJ   c                 S   s   g | ]}d | ‘qS ©ú%s = 0;r)   rÈ  r)   r)   r*   r“   ù  r”   r  z/*except:*/ {rÜ   Tz__Pyx_ErrRestore(0,0,0);r  c                    s   g | ]}ˆ j jtd d‘qS rŸ  rŒ  r  r  r)   r*   r“     s   ÿz&%s, &%s, &%sz"if (__Pyx_GetException(%s) < 0) %sr   Zexcept_breakZexcept_continue)0rç   r(   rŠ  rñ   rÄ  rÒ   rŸ  r   r!  rS   r:  rv  r&  r  rã  rä  r
   rA   r¯   r•  r  rê  r–   r¡   Úexcinfo_targetr€  rR  rZ  r  Úget_exception_utility_coderè  rç  r  Zset_varr‚  r–  rV   r  r  r#  r&  rÔ   rÈ   r(  r   r  rT  ré  )r‡   rY   r   Zhas_non_literalsr&  Zexc_test_funcZ	exc_testsrŠ  Z
match_flagrë  Zexc_argsr¿  ZtempvarrX   r–  r—  Úold_exc_varsr#  r›  r)   r  r*   r”  ×  s¶    þ

ÿ



ÿÿ
ÿþ



ÿÿ

ÿ
ÿz'ExceptClauseNode.generate_handling_codec                 C   s*   | j d ur| j  ||¡ | j ||¡ d S r‚   )r€  rÓ   r¡   rì   r)   r)   r*   rÓ   C  s    
z.ExceptClauseNode.generate_function_definitionsc                 C   s>   | j r| j D ]}| |¡ q| jr.| j |¡ | j |¡ d S r‚   )rŠ  r¢   r€  r¡   )r‡   rY   rŠ  r)   r)   r*   r¢   H  s    
zExceptClauseNode.annotate)rO   rr   rs   r•   r  r¥  Zis_except_asrœ   rw   r”  rÓ   r¢   r)   r)   r)   r*   rœ  «  s   lrœ  c                   @   s†   e Zd Zg d¢ZdZdZdZdZdZdZ	e
dd„ ƒZdd	„ Zd
d„ ZejZdZdd„ Zdd„ Zddd„Zddd„Zdd„ Zdd„ ZdS )ÚTryFinallyStatNode)r¡   Úfinally_clauseÚfinally_except_clauser   TNFc                 C   s   t | ||d}|S )N©r¡   r©  )r¨  )r(   rE   r¡   r©  rX   r)   r)   r*   rÝ   k  s    z"TryFinallyStatNode.create_analysedc                 C   s6   | j  |¡ t | j¡| _| j |¡ | j |¡ d S r‚   )r¡   rœ   r   Údeepcopyr©  rª  r‹   r)   r)   r*   rœ   p  s    z'TryFinallyStatNode.analyse_declarationsc                 C   sD   | j  |¡| _ | j |¡| _| j |¡| _|jr@|jjs@|j| _| S r‚   )r¡   rw   r©  rª  rK  rþ   Úfunc_return_typer‹   r)   r)   r*   rw   v  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 "|¡ ˆ  |¡ t#ˆ  ¡ |ƒD ]:\}}ˆ  |¡szqbˆ  |¡ ˆ $ˆ |¡ ˆ  |¡ qb|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rH|rˆ  dt*j+|f ¡ ˆj'j,rˆ  d| ¡ ˆ j "|¡ ˆjrHˆ !ˆ |¡ |D ]}ˆ j "|¡ q4ˆjjs\ˆ  |¡ ˆ  d¡ qâˆ  |¡ ˆ  d¡ d S )NrŽ  r   r  z/*finally:*/ {c                    s.   | d }t  |¡}|ˆ ju r&|| d< n|}|S rö  )r   r¬  r©  )Ú_nextrX   Z	node_copyr   r)   r*   Úfresh_finally_clauseœ  s    


zHTryFinallyStatNode.generate_execution_code.<locals>.fresh_finally_clausez/*normal exit:*/{z/*exception exit:*/{r  c                    s   g | ]}ˆ j jtjd d‘qS ©Frâ  )rã  rä  r
   rA   r  r  r)   r*   r“   ¸  s   ÿz>TryFinallyStatNode.generate_execution_code.<locals>.<listcomp>r#   Frâ  c                    s   g | ]}ˆ j jtd d‘qS r°  rŒ  r  r  r)   r*   r“   À  s   ÿé   r  r%   r)   z%s: {c                    s   g | ]}ˆ j jtd d‘qS r°  rŒ  r  r  r)   r*   r“   ñ  s   ÿrz  r¤  )-rç   r(   rS   rP  Zall_new_labelsÚget_all_labelsÚhandle_error_caser#  rã  Zin_try_finallyr¡   rÔ   r‘  r©  Úset_all_labelsÚpreserve_exceptionr  rÈ   rR  rT  r  Úis_try_finally_in_nogilr6  r:  rÄ  rä  r
   ZCPtrTyperg  rL  Úput_error_catcherr&  rª  Úput_error_uncatcherrê  r–  Úput_error_cleanerrS  rC  r­  rM   ÚGILExitNoder	   r0  r?   )r‡   rY   r  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§  rF  r#  r›  rS  rS  Zret_tempr)   )rY   r‡   r*   rÔ     sî    














þþþ
ÿ






þ
ÿ
þÿ





ÿz*TryFinallyStatNode.generate_execution_codec                 C   s    | j  ||¡ | j ||¡ d S r‚   )r¡   rÓ   r©  rì   r)   r)   r*   rÓ     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 ]}| 
|¡ q¨|rä| d|d tj|d tj|tjf ¡ | jrò| ¡  d S )NF©r6  r  rJ   c                 S   s   g | ]}d | ‘qS r£  r)   rÈ  r)   r)   r*   r“   $  r”   z8TryFinallyStatNode.put_error_catcher.<locals>.<listcomp>z>if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&%s, &%s, &%s);r%   zmif ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&%s, &%s, &%s) < 0)) __Pyx_ErrFetch(&%s, &%s, &%s);r#   ú%s = %s; %s = %s; %s = %s;r   r   )rÒ   rŸ  rW  r¦  Úswap_exception_utility_coder¶  r5  rS   r¯   r(  r“  r	   Úlineno_cnameÚclineno_cnameÚfilename_cnamerN  )	r‡   rY   r˜  r&  r»  r¼  r™  r3   r¿  r)   r)   r*   r·    s2    

ÿü

ýz$TryFinallyStatNode.put_error_catcherc              	   C   sú   |j  t¡ |j  t¡ | jr*|jdd | d¡ |dd … D ]}| |¡ q@| d|dd …  ¡ | d¡ |d d… D ]}| |¡ 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);r  r¢  rJ   c                 S   s   g | ]}d | ‘qS r£  r)   rÈ  r)   r)   r*   r“   Q  r”   z:TryFinallyStatNode.put_error_uncatcher.<locals>.<listcomp>r¾  r   r   )rÒ   rŸ  rW  r’  r¶  r5  rS   rb  rN  r¯   r	   rÀ  rÁ  rÂ  )r‡   rY   r&  r»  r¼  r¿  r)   r)   r*   r¸  <  s*    



ýz&TryFinallyStatNode.put_error_uncatcherc                 C   s¶   |j  t¡ | jr|jdd | d¡ |dd … D ]}| |¡ q4| d|dd …  ¡ | d¡ |d d… D ]}| |t¡ qp| jr| 	¡  | d 
dgd ¡|dd …  ¡ d S )	NFr½  rÃ  r%   rÄ  r  rJ   r¤  )rÒ   rŸ  r’  r¶  r5  rS   rb  r(  r   rN  r¯   )r‡   rY   r&  r¿  r)   r)   r*   r¹  X  s    

z$TryFinallyStatNode.put_error_cleanerc                 C   s   | j  |¡ | j |¡ d S r‚   )r¡   r¢   r©  rž   r)   r)   r*   r¢   j  s    zTryFinallyStatNode.annotate)NN)NN)rO   rr   rs   r•   rµ  r³  r­  rª  r¶  r  rê   rÝ   rœ   rw   r„   rŒ   rÌ   rŠ   rÔ   rÓ   r·  r¸  r¹  r¢   r)   r)   r)   r*   r¨  Q  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)rO   rr   rs   r€   rµ  rÌ   r)   r)   r)   r*   rÅ  o  s   rÅ  c                       s@   e Zd ZdZdd„ Zdd„ Z‡ fdd„Zdd	„ Zd
d„ Z‡  Z	S )ÚGILStatNodeNc              	   C   s6   || _ |  |||¡ tj| ||t||| jdd d S )N)ÚstateÚ
state_tempr«  )rÇ  Úcreate_state_temp_if_neededr¨  r‰   rº  rÈ  )r‡   r(   rÇ  r¡   r)   r)   r*   r‰     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  rS  rÈ  )r‡   r(   rÇ  r¡   rÊ  Ú	collectorrš  r  r)   r)   r*   rÉ  ˆ  s    
z'GILStatNode.create_state_temp_if_neededc                    s,   | j dk|_| j dkrd|_tt| ƒ |¡S )NrË  T)rÇ  Z_in_with_gil_blockr4  rj   rÆ  rœ   r‹   rq   r)   r*   rœ   –  s    
z GILStatNode.analyse_declarationsc                 C   s:   |  t dd¡¡ |j}| jdk|_t | |¡}||_|S )NZForceInitThreadsr¡  r8  )rŸ  r   r!  r8  rÇ  r¨  rw   )r‡   rE   Ú	was_nogilrX   r)   r)   r*   rw     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
|d d|j_t | |¡ | jr| j |¡ ||j_| ¡  d S )NrË  )ÚvariableTF)rç   r(   Úbegin_blockrÈ  r[  r™   rã  r%  rÇ  r5  Zput_release_gilr¨  rÔ   r]  Ú	end_block)r‡   rY   rÎ  Zold_gil_configr)   r)   r*   rÔ   ¦  s"    

z#GILStatNode.generate_execution_code)
rO   rr   rs   rÈ  r‰   rÉ  rœ   rw   rÔ   rt   r)   r)   rq   r*   rÆ  x  s   		rÆ  c                   @   s(   e Zd ZdZg ZdZdd„ Zdd„ ZdS )rº  z]
    Used as the 'finally' block in a GILStatNode

    state   string   'gil' or 'nogil'
    Nc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw   Ê  s    zGILExitNode.analyse_expressionsc                 C   s:   | j r| j  ¡ }nd }| jdkr,| |¡ n
| |¡ d S )NrË  )rÈ  r™   rÇ  rN  Zput_acquire_gil)r‡   rY   rÎ  r)   r)   r*   rÔ   Í  s    
z#GILExitNode.generate_execution_code)rO   rr   rs   r€   r•   rÈ  rw   rÔ   r)   r)   r)   r*   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½  )r5  rž   r)   r)   r*   rÔ   Þ  s    z%EnsureGILNode.generate_execution_codeN)rO   rr   rs   r€   rÔ   r)   r)   r)   r*   rÑ  Ù  s   rÑ  c                  C   s   ddl m}  | jS r™  )rº   r›  r   rš  r)   r)   r*   Úcython_view_utility_codeâ  s    rÒ  c                   C   s   t  dd¡S ©NZArrayAPIzarrayarray.h©r   r!  r)   r)   r)   r*   r§  ê  r”   rÖ  c                   C   s   t  dd¡S rÓ  rÔ  r)   r)   r)   r*   r§  ë  r”   )zcpython.arrayzcpython.array.arrayzcython.view)Z__Pyx_patch_asyncioZPatchAsyncIOrY  )Z__Pyx_patch_inspectZPatchInspectrY  )ÚasyncioÚinspectc                   @   s,   e Zd Zg ZdZdd„ Zdd„ Zdd„ ZdS )	ÚCImportStatNodeFc                 C   s  |j st| jdƒ d S |j| j| j| jr,dndd}d| jv 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tv r| t| j ƒ ¡ d S )	Nú$cimport only allowed at module levelr   r½   ©Úrelative_levelrš  c                 S   s   g | ]}t |ƒ‘qS r)   r   )r‘   r>   r)   r)   r*   r“     r”   z8CImportStatNode.analyse_declarations.<locals>.<listcomp>r   )r¿  r   r(   Úfind_modulerW  Úis_absoluter   rn  Zfind_submoduleÚdeclare_moduleÚas_namer«  Úutility_code_for_cimportsrŸ  )r‡   rE   Úmodule_scoper¶  Ztop_nameZtop_module_scoper>   Úsubmodule_scoper)   r)   r*   rœ     s.    ÿ


z$CImportStatNode.analyse_declarationsc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw     s    z#CImportStatNode.analyse_expressionsc                 C   s   d S r‚   r)   rž   r)   r)   r*   rÔ     s    z'CImportStatNode.generate_execution_codeN)rO   rr   rs   r•   rÜ  rœ   rw   rÔ   r)   r)   r)   r*   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r>| j|j d¡kr>t| jdƒ d S |j| j| j| jd}|j}| |¡ | j	D ]\}}}}|dkr¨t
|j ¡ ƒD ]\}}	| ||	|¡ qŽqj| |¡}	|	rØ|rÐ|  |	|¡sÐ|	 |¡ d|	_nŽ|dksè|dkrþ|j||d d	|d
}	nh|dkr|j|||d}	nL|jj||| jdd}
|
j|u rT| |pH||
| j¡ nt|d||f ƒ |	rj|pr|}| ||	|¡ qj| d¡sœ| d¡rò|tv r¶| t| ƒ ¡ | j	D ]4\}}}}d||f }|tv r¼| t| ƒ ¡ q¼d S )NrØ  rš  z3relative cimport beyond main package is not allowedrÙ  r5  r   rY  rÉ  r   )rZ  r[  r\  r(   Úclass)r(   rW  F)Úrelative_tor(   Zabsolute_fallbackz%Name '%s' not declared in module '%s'ÚcpythonÚcythonz%s.%s)r¿  r   r(   rÚ  r[  ÚcountrÛ  rW  r«  Úimported_namesr—   r×   ri   r¬  r  Údeclaration_matchesZ
redeclaredrb  r`  r¡  rn  Úparent_modulerÝ  rï  rß  rŸ  )r‡   rE   rà  rW  r(   r>   rÞ  rZ  Z
local_namerØ   rá  r±  Zfqnamer)   r)   r*   rœ   .  sP    



ÿ

ÿ


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   rã  r   )r£  r3   rä  Zis_struct_or_unionrZ  )r‡   rØ   rZ  r3   r)   r)   r*   ré  \  s    
z'FromCImportStatNode.declaration_matchesc                 C   s   | S r‚   r)   r‹   r)   r)   r*   rw   j  s    z'FromCImportStatNode.analyse_expressionsc                 C   s   d S r‚   r)   rž   r)   r)   r*   rÔ   m  s    z+FromCImportStatNode.generate_execution_code)rO   rr   rs   r•   rW  rÚ  rè  rœ   ré  rw   rÔ   r)   r)   r)   r*   râ  "  s   .râ  c                   @   s.   e Zd ZdgZdZdd„ Zdd„ Zdd„ Zd	S )
ÚFromImportStatNoderª  r   c                 C   sL   | j D ]@\}}|dkr<|js.t| jdƒ  d S d|_d| _q| |¡ qd S )Nr5  z%import * only allowed at module levelr   )ri   r¿  r   r(   Zhas_import_starÚimport_starr  )r‡   rE   r>   r€  r)   r)   r*   rœ   }  s    z'FromImportStatNode.analyse_declarationsc           	   	   C   sT  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y   Y n0 | |d ¡}|jtu r,d }n| j |j|¡}| j |||f¡ q6| S )Nr   r¦  r5  ZExtTypeTestrx  rW  )r(   rÚ  )rº   r  rª  rw   rt  r(   r   r«   Úinterned_itemsri   r×   r£  r3   rä  rŸ  r   r!  r  r>   rq  rW  r;   rÛ  r­   r[  r£   r’  rM  r&  )	r‡   rE   r  r>   r€  r±  rØ   rª  Úcoerced_itemr)   r)   r*   rw   ˆ  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 ¡ | |¡ |d u rÖ| | j|¡ n | |¡ | |¡ | ||¡ | |t¡ q~|j	 |¡ | j |¡ | j |¡ d S )Nzif (%s(%s) < 0) %s;Trâ  Ú
ImportFromr²  z!%s = __Pyx_ImportFrom(%s, %s); %s)rç   r(   rª  rv  rì  rS   r	   r  rè  rã  rä  r   r«   rz  rí  rÒ   rŸ  r   r!  r-  ræ  rç  r‚  Zallocate_temp_resultr{  ré  rê  r•  r  )r‡   rY   Z	item_tempr>   r€  rî  r)   r)   r*   rÔ   «  sF    
ýÿ
ÿüÿ


z*FromImportStatNode.generate_execution_codeN)rO   rr   rs   r•   rì  rœ   rw   rÔ   r)   r)   r)   r*   rë  q  s
   	#rë  c                   @   s   e Zd ZdZdZdS )ÚParallelNodez4
    Base class for cython.parallel constructs.
    N)rO   rr   rs   r€   rÌ   r)   r)   r)   r*   rð  Í  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i |¤Ž | d¡p$i | _tƒ | _i | _g | _d S )Nrå  )	rj   rñ  r‰   rˆ  rå  r   Úseen_closure_varsÚprivatesÚassigned_nodesrT  rq   r)   r*   r‰      s
    zParallelStatNode.__init__c              
   C   sD  | j  |¡ d | _| jrúg }tƒ }| jjD ]~}|jj|v 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 n2 työ } zt| jj	dƒ W Y d }~n
d }~0 0 ni | _| j ¡ D ]4\}}|| jvr0t| 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ò  rz   r   r:   rµ   r;   r   r(   r·   rÆ   Ú	is_prangerö  r&  rÊ  Ú	Exceptionri   Úvalid_keyword_argumentsr˜   )r‡   rE   ÚpairsÚseenZdictitemrž  rˆ   ro  r)   r)   r*   rœ   %   s4    

&z%ParallelStatNode.analyse_declarationsc                 C   sì   | j r| j  |¡| _ | jr(| j |¡| _| j |¡| _|  |¡ | j d urè| jrr| jj d u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ò  rw   rö  r¡   Úanalyse_sharing_attributesÚparentr÷  r   r(   r3   r  rÇ   rÊ  rž  r?   rM  r
   rA   r×  r‹   r)   r)   r*   rw   K   s0    


ÿþÿÿz$ParallelStatNode.analyse_expressionsc                 C   sj   | j  ¡ D ]Z\}\}}| jr:| js:|| jj v 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)rå  ri   r÷  Úis_parallelrý  r   Úpropagate_var_privatization)r‡   rE   rØ   r(   rÚ  Úlastprivater)   r)   r*   rü  d   s    


z+ParallelStatNode.analyse_sharing_attributesc                 C   sl   ||f| j |< |jjr$t|dƒ dS | jrh| jsF|| jjv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ô  r3   rÀ  r   r÷  rþ  rý  rå  rÿ  )r‡   rØ   r(   rÚ  r   rý  r)   r)   r*   rÿ  ~   s    5

z,ParallelStatNode.propagate_var_privatizationc                 C   s€   | j r| j  ||¡S |j| jv r&|jS |j |jd¡}| j |j¡ | j |¡ | j 	||jf¡ | 
d||jf ¡ ||_dS )zo
        Helper function that allocate a temporary for a closure variable that
        is assigned to.
        Trz  N)rý  Ú_allocate_closure_temprF  ró  rã  rä  r3   r·   Úmodified_entriesr&  rS   )r‡   rY   rØ   rF  r)   r)   r*   r  Å   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 */Frz  )Úsortedrô  ri   r3   Úinvalid_valuerS   rF  rw  )r‡   rY   Úexcluderã  rØ   rÚ  r   r  r)   r)   r*   Úinitialize_privates_to_nanÛ   s    



ÿz+ParallelStatNode.initialize_privates_to_nanc                 C   s0   | j }|jj}||j_| |¡ ||j_| ¡ S r‚   )Ú1begin_of_parallel_control_block_point_after_declsrã  Úownerrv  r™   )r‡   rY   rr  r¨   r  r)   r)   r*   Úevaluate_before_blockê   s    
z&ParallelStatNode.evaluate_before_blockc                 C   s&   | j dur"| d|  || j ¡ ¡ dS )zS
        Write self.num_threads if set as the num_threads OpenMP directive
        Nz num_threads(%s))rò  r*  r	  rž   r)   r)   r*   Úput_num_threadsö   s    
z ParallelStatNode.put_num_threadsc                 C   s2   g | _ t| jƒD ]}|js |jr|  ||¡ qdS )a  
        If a variable is in a scope object, we need to allocate a temp and
        assign the value from the temp to the variable in the scope object
        after the parallel section. This kind of copying should be done only
        in the outermost parallel section.
        N)r  r  rå  Zfrom_closurer.  r  )r‡   rY   rØ   r)   r)   r*   Ú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.
        rz  N)r  rS   rF  rã  rê  )r‡   rY   rØ   r¿  r)   r)   r*   Úrelease_closure_privates!  s    z)ParallelStatNode.release_closure_privatesr)   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_pointrþ  rã  Zstop_collecting_tempsrÊ   r  r?   rÀ  r&  r*  r¯   Úbreaking_label_usedr	   Úparallel_whyÚerror_label_usedÚextendÚparallel_excÚpos_info)
r‡   rY   Zexclude_tempsr¨   rÊ   rô  Zfirstprivatesrë  r3   Zshared_varsr)   r)   r*   Úprivatize_temps!  s&    
z ParallelStatNode.privatize_tempsc                 C   sd   | j r`| js`| d¡ t| jƒD ]>\}}|jr>|j|dd q |jr | ||¡ | d| ¡ q d S )Nz/* Clean up any temporaries */Fr  r&  )	rþ  Úis_nested_prangerS   r  rÊ   rÀ  r_  r?   rV  )r‡   rY   rë  r3   r)   r)   r*   Úcleanup_temps4!  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)rC  rE  r  r  rS  r•  r#  rÏ  r1  Ú%begin_of_parallel_control_block_pointr  Ú"undef_builtin_expect_apple_gcc_bugrž   r)   r)   r*   Ú!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)r1  Úbegin_of_parallel_blockrž   r)   r)   r*   Úbegin_parallel_blockd!  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_THREADSz#elsez{
z#ifndef _OPENMPz}
)r  r  rS   r5  Zput_safer  rN  )r‡   rY   Z
begin_codeZend_coder)   r)   r*   Úend_parallel_blocko!  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)r#  Úany_label_usedr  r  Úparallel_private_tempsr²  r  r  rR  rC  rT  rP  Úfetch_parallel_exceptionrS   r	   r  r÷  Úsave_parallel_varsr  )	r‡   rY   Úshould_flushZsave_lastprivates_labelZdont_return_labelZ
all_labelsrp  rS  Zis_continue_labelr)   r)   r*   Ú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 
¡ }d| }	|j}
|d7 }|j ¡ }|r d|j |¡ }nd}| d||	|f ¡ | d	|	|
f ¡ | j |	|
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__pyx_parallel_temp%dr	  rº   z%s %s%s;rz  N)Úcritical_section_counterr  rñ  rÏ  r  r  rô  ri   r3   r?   rp  rF  r  rw  rS   r#  r&  rÐ  )r‡   rY   Úsection_namer¨   Z
temp_countrØ   rÚ  r   Z	type_declÚ
temp_cnameÚprivate_cnamer  rl  r)   r)   r*   r%  Ó!  s*    	


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¡ | 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!  z
if (!%s) {z'__Pyx_ErrFetchWithState(&%s, &%s, &%s);r¾  r  N)rÏ  r5  r  r	   Úparallel_exc_typerS   r  r   r–  Úparallel_pos_infor  rã  Zuses_error_indicatorr:  rç  rN  rÐ  ©r‡   rY   r  r)   r)   r*   r$  þ!  s     ÿÿz)ParallelStatNode.fetch_parallel_exceptionc                 C   sh   |  ¡  |jdd | tj¡ | d| j ¡ tt| j	| j
ƒŽ }| dt|ƒ ¡ | ¡  | ¡  dS )zRe-raise a parallel exceptionTr½  r$  r¾  N)rÏ  r5  r}  r	   r,  rS   r  r   r–  r  r-  r:  rN  rÐ  r.  r)   r)   r*   Ú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´  rE  r•  r  rž   r)   r)   r*   Úrestore_labels9"  s    ÿzParallelStatNode.restore_labelsc           	      C   sº  | j }d| _ d| _| jdu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 ]\}}| d
||f ¡ qÜ| dt	j ¡ |r$| d¡ | |j¡ |r@| d¡ | |j¡ |r\| d¡ | |j¡ | jr|j t¡ | d¡ |  |¡ | |j¡ | d¡ | d¡ | ¡  |  |¡ dS )aÕ  
        This ends the parallel control flow block and based on how the parallel
        section was exited, takes the corresponding action. The break_ and
        continue_ parameters indicate whether these should be propagated
        outwards:

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

        Here break should be trapped in the parallel block, and propagated to
        the for loop.
        Nz*const char *%s = NULL; int %s = 0, %s = 0;z,PyObject *%s = NULL, *%s = NULL, *%s = NULL;r  zg/* This may have been overridden by a continue, break or return in another thread. Prefer the error. */z%s = 4;r  zint %s;r¤  rz  r>  z    case 1: z    case 2: z    case 3: z    case 4:)r  r  rò  r•  r  r  rS   r-  r  r	   r,  r  r"  r  r#  r*  rR  r  r  rS  rÒ   rŸ  rW  r/  rP  rÐ  Ú"redef_builtin_expect_apple_gcc_bug)	r‡   rY   Úbreak_Ú	continue_Úreturn_r¨   r"  r*  r+  r)   r)   r*   Úend_parallel_control_flow_blockA"  sb    
ÿ
ÿÿ





ÿ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)rý  Zundef_builtin_expectÚredef_conditionrž   r)   r)   r*   r  –"  s    z3ParallelStatNode.undef_builtin_expect_apple_gcc_bugc                 C   s   | j s| | j¡ d S r‚   )rý  Zredef_builtin_expectr6  rž   r)   r)   r*   r1  "  s    z3ParallelStatNode.redef_builtin_expect_apple_gcc_bug)N)r)   )F)FFF)5rO   rr   rs   r€   r•   r¡   r÷  r  r  rò  rö  r	   r,  Zparallel_exc_valueZparallel_exc_tbr  Zparallel_filenameZparallel_linenoZparallel_clinenor-  rÂ  rÀ  rÁ  r  r(  r‰   rœ   rw   rü  rÿ  r  r  r	  r
  r  r  r  r  r  r  r   r'  r%  r$  r/  r0  r5  Zbuggy_platform_macro_conditionZhave_expect_conditionr6  r  r1  rt   r)   r)   rq   r*   rñ  Õ  sb   ýýý&G

%!
C+.	 ÿ
P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)rj   r7  rœ   rV   r   r(   r‹   rq   r)   r*   rœ   «"  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 r)   )r3   r?   rF  )r‘   rž  r)   r)   r*   r“   ¹"  s   ÿzAParallelWithBlockNode.generate_execution_code.<locals>.<listcomp>zprivate(%s)rª   rº   r  )r2  r3  r4  )r  r  rS   r*  rô  r¯   r  r1  r  r
  rÏ  r  r  rã  Ústart_collecting_tempsr¡   rÔ   r'  r  r   rÐ  r  r  r  rS  r0  r5  r  )r‡   rY   rô  r3  r2  r4  r)   r)   r*   rÔ   ±"  s:    














þz-ParallelWithBlockNode.generate_execution_code)	rO   rr   rs   r€   rù  rò  rœ   rÔ   rt   r)   r)   rq   r*   r7  ¢"  s
   r7  c                       sˆ   e Zd ZdZg d¢Zd Z Z ZZd Z	 Z
ZdZdZdZg d¢Z‡ fdd„Z‡ fdd	„Z‡ fd
d„Zdd„ Zdd„ Zdd„ Z‡  ZS )ÚParallelRangeNodezÌ
    This node represents a 'for i in cython.parallel.prange():' construct.

    target       NameNode       the target iteration variable
    else_clause  Node or None   the else clause of this loop
    )r¡   r€  r+  rV   rò  rö  NT)Úscheduler8  rò  rö  c                    s&   t t| ƒj|fi |¤Ž t|ƒ| _d S r‚   )rj   r9  r‰   r¼  rc  )r‡   r(   rW   rq   r)   r*   r‰   î"  s    zParallelRangeNode.__init__c                    sÜ   t t| ƒ |¡ | j |¡ | jd u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\| _| _
| _t| jdƒrº| j d¡| _| jdvrØt| j	d| jf ƒ d S )	Nr%   z0Invalid number of positional arguments to pranger   r#   ÚdecodeÚascii)NZstaticZdynamicZguidedÚruntimez'Invalid schedule argument to prange: %s)rj   r9  rœ   r€  r  r+  rV   rL   r   r(   rÐ  r[   ro  rq  r:  r;  r‹   rq   r)   r*   rœ   ó"  s     

z&ParallelRangeNode.analyse_declarationsc                    sL  |j }| j rd|_ | jd u 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 urš| |¡ |jjsÎt|jd| ƒ qš|jsê| |¡}t| ||ƒ t | j
|j¡| _
qš| jd ur| j |¡| _t| jdƒr<| jjd f| j| jj< tt| ƒ |¡}|jrÖ|jslt|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$rH|}|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)r[   rÐ  ro  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))r8  r€  r   r(   rx   r3   r“  r?   r
   r)  Ú
index_typer¶  r[   rÐ  ro  r–  rv   rÇ   r×  r˜   rr  r+  rw   rq  rå  rØ   rj   r9  rö  r:  r  rÊ  rM  rA   rý  r÷  r  r†   rô  rõ  r  )r‡   rE   rÍ  Ústart_stop_steprX   r>   rý  rq   r)   r*   rw   
#  s€    



ÿ



ÿÿÿÿþÿÿ
z%ParallelRangeNode.analyse_expressionsc                 C   sP   d}| j | j| j| jf}t||ƒD ](\}}|d ur"|jjr"t|jd| ƒ q"d S )N)r[   rÐ  ro  r€  z6%s may not be a Python object as we don't have the GIL)	r[   rÐ  ro  r€  r–  r3   r?   r   r(   )r‡   rE   r¶  Únodesr>   rX   r)   r)   r*   rÌ   _#  s    ÿzParallelRangeNode.nogil_checkc                 C   s¾  |   |¡ | jjj}|| jj ¡ dœ}| j| j| jf}d}t	|| j
|ƒD ]B\}}}|du r`|}	n"|jrp| ¡ }	n| |¡ | ¡ }	|	||< qH|j | jd¡|d< |j | jd¡|d< | d| ¡ |  |¡ | d| ¡ | d	| ¡ | ¡  |  ||¡ | ¡  |  |¡ | jrT| jr.| d
tj ¡ | ¡  | d¡ | j |¡ | ¡  |  |¡ || jf D ]$}
|
durj|
  |¡ |
 !|¡ qj|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€  ro  )rÇ  rÇ  rv  NFrS  Znstepszif ((%(step)s == 0)) abort();zS%(nsteps)s = (%(stop)s - %(start)s + %(step)s - %(step)s/abs(%(step)s)) / %(step)s;zif (%(nsteps)s > 0)úif (%s < 2)z
/* else */)$r  r€  rØ   rF  r3   rp  r[   rÐ  ro  r–  r¶  rÇ   r  rv  r™   rã  rä  r>  rS   r  rÏ  Úgenerate_looprÐ  r0  r+  r  r*  r	   r  rÔ   r5  rö  r•  r  rê  r  )r‡   rY   Ztarget_index_cnameÚfmt_dictr?  ÚdefaultsrX   r>   rø   r™   rë  r)   r)   r*   rÔ   g#  sP    (


þ








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v 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)r  z lastprivate(%s)r   r´  z %s(%s)z, %sz schedule(%s%s)z,for (%(i)s = 0; %(i)s < %(nsteps)s; %(i)s++)z=%(target)s = (%(target_type)s)(%(start)s + %(step)s * %(i)s);)r  T)r&  rA  )#r  rS   rþ  r*  r1  r  rý  rÏ  r  r  rô  ri   r€  rØ   r3   r?   r   r(   rF  r:  rö  r	  r
  r  rã  r8  r¡   rÔ   r'  r  r  r	   r  rÐ  r   )
r‡   rY   rC  Zreduction_codepointrØ   rÚ  r   r´  rö  Zguard_around_body_codepointr)   r)   r*   rB  Ú#  sz    










ÿ





zParallelRangeNode.generate_loop)rO   rr   rs   r€   r•   r¡   r€  r+  rV   r[   rÐ  ro  r÷  r8  r:  rù  r‰   rœ   rw   rÌ   rÔ   rB  rt   r)   r)   rq   r*   r9  Ø"  s   Usr9  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
    rX   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v 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±  )rX   rœ   rM   rÎ   r¡   rÜ   rï  Úis_functionrÇ  rß  rØ   rF  r¹  rb  r÷  r_  r3   r[  rœ  r	   Ztypeobj_prefixr  r@  r“  r¡  rö  r×   ri   )r‡   rE   rX   Zis_struct_or_enumrž  r[  r>   rØ   r)   r)   r*   rœ   O$  s8    
z'CnameDecoratorNode.analyse_declarationsc                 C   s$   d|v r|  d¡d }d| j|f S )Nrš  r½   z%s_%s)r   rF  )r‡   rF  r)   r)   r*   r_  u$  s    zCnameDecoratorNode.manglec                 C   s   | j  |¡| _ | S r‚   )rX   rw   r‹   r)   r)   r*   rw   {$  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)rH  rD  rÒ   rM   rX   r   r)  rº   rI  rØ   rF  r¹  Zgenerate_cfunction_declarationrÖ   rÓ   )r‡   rE   rY   Zh_coderI  rØ   rF  r)   r)   r*   rÓ   $  s$    
ÿüz0CnameDecoratorNode.generate_function_definitionsc                 C   s   | j  |¡ d S r‚   )rX   rÔ   rž   r)   r)   r*   rÔ   ˜$  s    z*CnameDecoratorNode.generate_execution_codeN)
rO   rr   rs   r€   r•   rœ   r_  rw   rÓ   rÔ   r)   r)   r)   r*   rE  ?$  s   &rE  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;
}
)rZ  ÚimplÚrequires)N)¥Ú
__future__r   ræ  rË  r  r   r   r   Ú	itertoolsr   rº   r   ZErrorsr   r   r   r   r	   r
   r   r   r   ZSymtabr   r   r   r   r   r   r   rg   r   ZStringEncodingr   r   r   r   ZPythranr    r!   r"   ZUtilsr$   r­  r5   r   r6   r+   r2   rI   ra   r3   rb   ru   rƒ   r„   rÎ   r    rÛ   rë   rí   rô   r÷   r  r  r  r"  re  ri  r‰  rC   rŒ  r•  r¡  rr  r°  r²  r´  r¸  rî   rÇ  rÎ  rß  rì  rí  rï  rÚ  rÌ  rŸ  r   rÞ  rQ  r^  r`  ra  rb  r¤  r|  r~  rŒ  r´  rµ  r¸  rw  rÂ  rÆ  rí  rÃ  r÷  rÿ  r  r
  r¼  r  r  r  r®  r  r#  r(  r)  r4  r7  r;  rA  rB  rF  r`  rh  ri  rf  re  rg  r  r…  r‡  rœ  r¨  rÅ  rÆ  rº  rÑ  rÒ  rß  Zutility_code_for_importsr×  râ  rë  rð  rñ  r7  r9  rE  Zgcc_branch_hintsZbranch_prediction_macrosr!  r  r  rW  r"  r¦  r¿  r’  Ztraceback_utility_codeZ get_exception_tuple_utility_coder)   r)   r)   r*   Ú<module>   s‚  

û$
/ ,*%#, Bt	^!Q'm-X1!                  08 9r N   @  2f/GC)8
sh=C)$/<\<
a
 pg! + '   	H	ûü+O\     R6  icæ