B
    Í‹dÝú ã               @   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&   úb/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/Cython/Compiler/Nodes.pyÚrelative_position)   s    r(   c             C   s„   t js
|S dt| ƒ }|d kr&t|ƒS |j}|d k	r\y| |¡ W n tk
rZ   d }Y nX |sjt|ƒ}nt|d | ƒ}||_|S )NzFile: %s (starting at line %s)Ú
)r   Zembed_pos_in_docstringr(   r   ÚencodingÚencodeÚUnicodeEncodeError)r%   Z	docstringZpos_liner*   Údocr&   r&   r'   Úembed_position-   s     

r.   c             C   sz  d }d}d }}| j r|t| jdƒ xD| jD ]:\}}|js:q*|jdkrRd}|sd|} q*|jdkr*d}|} q*W |r||r|t| jdƒ |  |¡}	| jrø| jsø| j	dkrø|d k	rÎ|	d k	rÎ|	j
sÎ| |¡}
|
rÎ|
j
rÎd}d }	|	tjtjtjfkrö| j	dkròtjnt}	n|	d k	r| jrt| jd	ƒ |	d k	rR|r@|s@|	j
s@t| jd
ƒ t| j|	dd}n |rft| 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Úfloatr3   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)r/   Ú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:   r7   Úarg_typeZassigned_typer&   r&   r'   Úanalyse_type_annotationG   sP    





rE   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  _ˆ| |Ž}| jd8  _||jj ¡ kr¸|jj 
|¡ n| ddd¡}| 	|¡ |S ˆ| |Ž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&   )rZ   rY   r[   r&   )rY   rZ   r'   Úwrite_func_callv   s    r\   c                   s   e Zd Z‡ fdd„Z‡  ZS )ÚVerboseCodeWriterc                sd   ddl m} ddlm} t|ƒ}x,| ¡ D ] \}}t||ƒr*t||ƒ||< q*W tt	| ƒ 
| |||¡S )Nr   )ÚFunctionTyper   )ÚCCodeWriter)Útypesr^   ÚCoder_   ÚdictÚitemsrI   r\   Úsuperr]   Ú__new__)Úclsr:   ÚbasesÚattrsr^   r_   ÚmnameÚm)rJ   r&   r'   re   –   s    
zVerboseCodeWriter.__new__)rK   Ú
__module__Ú__qualname__re   Ú__classcell__r&   r&   )rJ   r'   r]   “   s   r]   c                   s.   e Zd ZdZedddgƒZ‡ fdd„Z‡  ZS )ÚCheckAnalyserszCMetaclass to check that type analysis functions return a node.
    Úanalyse_typesÚanalyse_expressionsÚanalyse_target_typesc                sj   ddl m} dd„ }t|ƒ}x6| ¡ D ]*\}}t||ƒr&|| jkr&|||ƒ||< q&W tt| ƒ | |||¡S )Nr   )r^   c                s   ‡ ‡fdd„}|S )Nc                 s(   ˆ | |Ž}|d kr$t dˆ| |f ƒ |S )Nz%s %s %s)Úprint)rR   ÚkwargsÚretval)rZ   r:   r&   r'   Úcallª   s    
z3CheckAnalysers.__new__.<locals>.check.<locals>.callr&   )r:   rZ   ru   r&   )rZ   r:   r'   Úcheck©   s    z%CheckAnalysers.__new__.<locals>.check)	r`   r^   rb   rc   rI   Úmethodsrd   rn   re   )rf   r:   rg   rh   r^   rv   ri   rj   )rJ   r&   r'   re   §   s    zCheckAnalysers.__new__)rK   rk   rl   Ú__doc__Úsetrw   re   rm   r&   r&   )rJ   r'   rn       s
   rn   c             C   s   t jrttƒ| ƒS | S )N)r   Zdebug_trace_code_generationr#   r]   )rf   r&   r&   r'   Ú_with_metaclass¸   s    rz   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 )N)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~   rA   r&   r&   r'   Ú	gil_erroræ   s    zNode.gil_errorc             C   s   |  ¡ s|  ¡  d S )N)Zis_cppÚ	cpp_error)r~   rA   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   sH   t   | ¡}x8|jD ].}t||ƒ}t|tƒrt||dd„ |D ƒƒ qW |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>ü   s    z#Node.clone_node.<locals>.<listcomp>)r   Úchild_attrsÚgetattrrI   ÚlistÚsetattr)r~   ÚresultÚattrnamer7   r&   r&   r'   Ú
clone_nodeò   s    


zNode.clone_nodec             C   s   d S )Nr&   )r~   rA   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   rJ   rK   )r~   rA   r&   r&   r'   rp     s    zNode.analyse_expressionsc             C   s   t d| jj ƒ‚d S )Nz$generate_code not implemented for %s)r   rJ   rK   )r~   rU   r&   r&   r'   Úgenerate_code  s    zNode.generate_codec             C   s   t | tƒr| j |¡ d S )N)rI   Ú	BlockNodeÚbodyÚannotate)r~   rU   r&   r&   r'   r”   "  s    
zNode.annotatec          	   C   s–   y| j S  tk
r   | j}| js,|| _ |S xX| jD ]N}t| |ƒ}|d krLq4t|tƒrtx*|D ]}t|| ¡ ƒ}q\W q4t|| ¡ ƒ}q4W || _ |S X d S )N)	Z_end_posÚAttributeErrorr%   r‰   rŠ   rI   r‹   ÚmaxÚend_pos)r~   r%   ÚattrÚchildÚcr&   r&   r'   r—   '  s"    


zNode.end_pos©r%   éd   c       
   	      sð   ˆ dkrdS ˆdkrt ƒ ‰t| ƒˆkr:d| jjt| ƒf S ˆ t| ƒ¡ ‡ ‡‡‡fdd„‰‡fdd„| j ¡ D ƒ}t|ƒdkr’d	| jjt| ƒf S d
| }d| jjt| ƒf }x,|D ]$\}}	|d||ˆ|	|d ƒf 7 }q´W |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]z, c                s   g | ]}ˆ |ˆƒ‘qS r&   r&   )r†   Úitem)Ú
dump_childÚlevelr&   r'   rˆ   K  s    z1Node.dump.<locals>.dump_child.<locals>.<listcomp>)rI   r{   Údumpr‹   ÚjoinÚrepr)r‡   rŸ   )Úcutoffrž   ÚencounteredÚ
filter_out)rŸ   r'   rž   G  s
    

zNode.dump.<locals>.dump_childc                s    g | ]\}}|ˆ kr||f‘qS r&   r&   )r†   Úkeyr7   )r¥   r&   r'   rˆ   O  s    zNode.dump.<locals>.<listcomp>z<%s (0x%x)>z  z<%s (0x%x)
z%s  %s: %s
r   z%s>)ry   ÚidrJ   rK   Úaddr|   rc   rH   )
r~   rŸ   r¥   r£   r¤   rh   ÚindentrX   r¦   r7   r&   )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_columnrV   Zsource_descÚlineÚcolÚcontentsÚlinesÚcurrentr&   r&   r'   Údump_posZ  s    zNode.dump_pos)N)r   r›   rœ   N)Frª   )rK   rk   rl   r9   Ú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   rp   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 )N)Ú
directivesr“   r   )r~   rA   Úoldr&   r&   r'   r   t  s    z+CompilerDirectivesNode.analyse_declarationsc             C   s&   |j }| j |_ | j |¡| _||_ | S )N)rÀ   r“   rp   )r~   rA   rÁ   r&   r&   r'   rp   z  s
    z*CompilerDirectivesNode.analyse_expressionsc             C   s8   |j }|jj }| j |j_ | j ||¡ ||_ ||j_ d S )N)rÀ   Úglobalstater“   Úgenerate_function_definitions)r~   rA   rU   Zenv_oldZcode_oldr&   r&   r'   rÃ     s    
z4CompilerDirectivesNode.generate_function_definitionsc             C   s*   |j j}| j|j _| j |¡ ||j _d S )N)rÂ   rÀ   r“   Úgenerate_execution_code)r~   rU   rÁ   r&   r&   r'   rÄ   ‰  s    
z.CompilerDirectivesNode.generate_execution_codec             C   s*   |j j}| j|j _| j |¡ ||j _d S )N)rÂ   rÀ   r“   r”   )r~   rU   rÁ   r&   r&   r'   r”     s    
zCompilerDirectivesNode.annotateN)
rK   rk   rl   rx   r‰   r   rp   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   s2   |  ¡ j}x|D ]}|j |¡ qW |d d …= d S )N)Úglobal_scopeZundeclared_cached_builtinsrÂ   Zadd_cached_builtin_decl)r~   rA   rU   ÚentriesÚentryr&   r&   r'   Úgenerate_cached_builtins_decls˜  s    

z(BlockNode.generate_cached_builtins_declsc             C   s    x|j D ]}| ||¡ qW d S )N)Zlambda_defsrÃ   )r~   rA   rU   rT   r&   r&   r'   Úgenerate_lambda_definitionsž  s    z%BlockNode.generate_lambda_definitionsN)rK   rk   rl   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 | f|ž|Ž}|S )N)rÊ   )r%   rA   rR   r   rT   r&   r&   r'   Úcreate_analysed§  s    zStatListNode.create_analysedc             C   s   x| j D ]}| |¡ qW d S )N)rË   r   )r~   rA   Ústatr&   r&   r'   r   ¬  s    z!StatListNode.analyse_declarationsc                s   ‡ fdd„| j D ƒ| _ | S )Nc                s   g | ]}|  ˆ ¡‘qS r&   )rp   )r†   rÍ   )rA   r&   r'   rˆ   ³  s   z4StatListNode.analyse_expressions.<locals>.<listcomp>)rË   )r~   rA   r&   )rA   r'   rp   ±  s    
z StatListNode.analyse_expressionsc             C   s    x| j D ]}| ||¡ qW d S )N)rË   rÃ   )r~   rA   rU   rÍ   r&   r&   r'   rÃ   ·  s    z*StatListNode.generate_function_definitionsc             C   s*   x$| j D ]}| |j¡ | |¡ qW d S )N)rË   Úmark_posr%   rÄ   )r~   rU   rÍ   r&   r&   r'   rÄ   ¼  s    z$StatListNode.generate_execution_codec             C   s   x| j D ]}| |¡ qW d S )N)rË   r”   )r~   rU   rÍ   r&   r&   r'   r”   Â  s    zStatListNode.annotateN)rK   rk   rl   r‰   ÚstaticmethodrÌ   r   rp   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 )Nr&   )r~   rA   rU   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 %s)r   rJ   rK   )r~   rU   r&   r&   r'   rÄ   ×  s    z StatNode.generate_execution_codeN)rK   rk   rl   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 )N)rI   ÚCVarDefNode)r†   rT   r&   r&   r'   ú	<genexpr>ò  s    z6CDefExternNode.analyse_declarations.<locals>.<genexpr>)	Úin_cincluder“   r   Zinclude_fileZverbatim_includerË   rÀ   ÚallÚadd_include_file)r~   rA   Zold_cinclude_flagrË   Zlater&   r&   r'   r   ã  s    
z#CDefExternNode.analyse_declarationsc             C   s   | S )Nr&   )r~   rA   r&   r&   r'   rp   õ  s    z"CDefExternNode.analyse_expressionsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rÄ   ø  s    z&CDefExternNode.generate_execution_codec             C   s   | j  |¡ d S )N)r“   r”   )r~   rU   r&   r&   r'   r”   û  s    zCDefExternNode.annotateN)rK   rk   rl   r‰   r   rp   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 )Nr&   )r~   r&   r&   r'   Úanalyse_templates  s    z!CDeclaratorNode.analyse_templatesN)rK   rk   rl   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«   zMissing argument namezJUse spam() rather than spam(void) to declare a function with no arguments.r   )Zfor_displayÚpyrex)r:   Úis_ptrÚis_arrayÚ	is_bufferr   r%   Úis_voidÚdeclaration_coder   Úis_fusedÚfused_to_specificÚ
specializer/   )r~   rC   rA   ÚnonemptyÚ
visibilityÚin_pxdr&   r&   r'   Úanalyse  s    zCNameDeclaratorNode.analyse)r   NF)rK   rk   rl   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 )N)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~   rC   rA   rå   ræ   rç   Zptr_typer&   r&   r'   rè   8  s    
zCPtrDeclaratorNode.analyse)r   NF)rK   rk   rl   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 )N)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 object)rå   ræ   rç   )r;   r   r%   r
   Z
c_ref_typerê   rè   )r~   rC   rA   rå   ræ   rç   Zref_typer&   r&   r'   rè   G  s    
z CReferenceDeclaratorNode.analyse)r   NF)rK   rk   rl   r‰   rØ   rè   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                sf  |j r| ¡ s|jrœddlm} t| j|ƒr6| jj}n| jf}‡ fdd„|D ƒ}d |k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 k	rüyt|
ƒ}
W n tk
rú   Y nX nd }
| ¡ st	| j
d| ƒ |jr0t	| j
d	ƒ |jrDt	| j
d
ƒ t ||
¡}| jj|ˆ |||dS )Nr   )Ú	TupleNodec                s   g | ]}|  ˆ ¡‘qS r&   )r8   )r†   Úv)rA   r&   r'   rˆ   [  s    z0CArrayDeclaratorNode.analyse.<locals>.<listcomp>zTemplate parameter not a type)rå   ræ   rç   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ï   rI   rî   rR   Úindexr   r%   r   Úspecialize_hererê   rè   Úanalyse_const_expressionr/   Úis_intÚget_constant_c_result_coder1   Ú
ValueErrorÚis_completer;   r
   Zc_array_type)r~   rC   rA   rå   ræ   rç   rï   rR   ÚvaluesÚixÚsizeZ
array_typer&   )rA   r'   rè   T  s>    




zCArrayDeclaratorNode.analyse)r   NF)rK   rk   rl   r‰   rè   r&   r&   r&   r'   rí   N  s   rí   c               @   sB   e Zd ZdddgZdZdZdZdZdd„ Zdd	d
„Z	ddd„Z
dS )ÚCFuncDeclaratorNoderê   rR   Ú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 | _
x8|D ]0}t ||ƒrˆ| j
 t |j¡¡ qdt|j	dƒ qdW | jj| _| j
S d S d S )Nr   )rï   ÚNameNodez*Template arguments must be a list of names)rI   rê   rí   rô   rï   r  rî   rR   r   r%   Ú	templatesÚappendr
   ÚTemplatePlaceholderTyper:   )r~   rï   r  Útemplate_nodeZtemplate_nodesÚtemplater&   r&   r'   rØ   Œ  s"    




z%CFuncDeclaratorNode.analyse_templatesFc                sä  |d kri }|r|d8 }g }x>t ˆjƒD ].\}}	|	jˆ ||dkoRˆ joRdˆ jkd\}
}|
j}||krÆ|| }| ˆ ¡}|d kr’t|jdƒ n4|t	j
k	rÂ| |¡sÂtˆjjdƒ t|jdƒ n|}|
jrØtˆjdƒ |dkròˆ jrò|jròˆ j}|jrt	 |j¡}|jrt|	jd	ƒ | t	 |||	j¡¡ |	jrHˆ jd7  _q*ˆjr*tˆjd
ƒ q*W 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 kr2ˆjr2ˆjdkr2|jd k	r2|dkr2|s2ˆ js2d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 k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_argz
Not a typez2Signature does not agree with previous declarationzPrevious declaration herez2Function argument cannot have C name specificationzJUse spam() rather than spam(void) to declare a function with no arguments.z-Non-default argument follows default argumentú+ZiosÚnewZ	stdexceptZtypeinfozAException clause not allowed for function returning Python objectÚextern)Ú	ConstNode)r7   r/   Ú*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 )N)Údeclare_optional_arg_struct)Ú	func_typeÚfused_cname)rA   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Ú	enumeraterR   rè   Úis_c_class_scoperÀ   r:   r8   r   r%   r
   r   Úsame_asrê   ÚcnameÚis_unspecifiedÚparent_typerÞ   rë   rC   rà   r  ÚCFuncTypeArgrÛ   r  r  rÖ   r;   r   rô   r  r÷   r/   Úis_errorró   Úreturn_typeÚc_char_typer7   Ú	coerce_torù   r   rJ   rK   Úassignable_fromÚ	CFuncTypeÚhas_varargsrÙ   r  r  Úoverridabler  r  râ   r  r  )r~   r   rA   rå   Údirective_localsræ   rç   Zfunc_type_argsÚiZarg_nodeÚname_declaratorr/   r:   Ú	type_nodeÚ
other_typeÚexc_valÚ	exc_checkr  Zexc_val_typer  r  r  rµ   r&   )rA   r~   r'   rè   ¢  sÆ     






 




zCFuncDeclaratorNode.analysec       	      C   sÀ   t ƒ }dtj }| |tj| j¡ x<|jt|jƒ| j	 d… D ]}|j|j
|j|jddd q>W | tj| jj
¡}|dk	r†t ||¡}| ¡ j|d|d| j|d}d|_d|_t |j¡|_dS )	a  
        Declares the optional argument struct (the struct used to hold the
        values for optional arguments). For fused cdef functions, this is
        deferred as analyse_declarations is called only once (on the fused
        cdef function).
        z%snNT)Zallow_pyobjectZallow_memoryviewÚstructr   )r:   ÚkindÚscopeÚtypedef_flagr%   r  r   )r   r	   Úpyrex_prefixÚdeclare_varr
   r=   r%   rR   rH   r  r:   r/   ÚmangleZopt_arg_prefixrê   Zget_fused_cnamerÅ   Údeclare_struct_or_unionÚdefined_in_pxdÚusedrë   Úop_arg_struct)	r~   r  rA   r  r0  Zarg_count_memberÚargZstruct_cnameZop_args_structr&   r&   r'   r    s$    
 z/CFuncDeclaratorNode.declare_optional_arg_struct)r   NNF)N)rK   rk   rl   r‰   r&  r  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 )Nz)Const base type cannot be a Python object)rå   ræ   rç   )r;   r   r%   r
   Úc_const_typerê   rè   )r~   rC   rA   rå   ræ   rç   Úconstr&   r&   r'   rè   @  s
    
zCConstDeclaratorNode.analyse)r   NF)rK   rk   rl   r‰   rè   r&   r&   r&   r'   r:  ;  s   r:  c               @   sx   e Zd ZddddgZddgZdZdZdZdZdZ	dZ
dZdZdZdZdZdd	d
„Zdd„ Zdd„ Zdd„ Zddd„ZdS )ÚCArgDeclNoderC   Ú
declaratorrÛ   r@   r   r   NFc       
      C   sx  |rd | j _| _| jd krht| 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}xt|jtƒr|j}qîW | j j|_|j }| jrV|rV|jd rV| j jd krV|  |¡}	|	d k	rV|	}| jj|||dS | j| jfS d S )NTr«   )Úcould_be_nameFÚarg_nameÚannotation_typing)rå   )rC   r  r/   rI   r>  rÚ   r:   Úis_basic_c_typerè   Úempty_declaration_coder   r4   Úhasattrr@  rÞ   ÚTemplatedTypeNoderí   rê   Úarray_declaratorr@   rÀ   Úinject_type_from_annotationsr)  )
r~   rA   rå   r  r/   r@  r?  rC   r>  rD   r&   r&   r'   rè   g  s@    


(

zCArgDeclNode.analysec             C   s4   | j }|sd S t||| jd\}}|d k	r0|| _|S )N)rB   )r@   rE   rÛ   rC   )r~   rA   r@   rC   rD   r&   r&   r'   rG  •  s    z)CArgDeclNode.inject_type_from_annotationsc             C   sJ   | j d krD| jrD| jjr6| j |¡ | j | j ¡ ¡S | | j¡| _ | j S )N)Údefault_valuerÛ   r¸   Úgenerate_evaluation_coder/   Ú	cast_coder   Zget_argument_default_const)r~   rU   r&   r&   r'   Úcalculate_default_value_codež  s    
z)CArgDeclNode.calculate_default_value_codec             C   s   | j r| j  |¡ d S )N)rÛ   r”   )r~   rU   r&   r&   r'   r”   ¨  s    zCArgDeclNode.annotatec             C   s–   | j }|d ks|jrd S |d kr*|  |¡}| |¡ | |¡ |rJ| ¡ n
| | j¡}| d||f ¡ | jj	r~| 
| ¡ ¡ | |¡ | |¡ d S )Nz%s = %s;)rÛ   r¸   rK  rI  Úmake_owned_referencer   Ú	result_asr/   rO   r;   Úput_giverefÚgenerate_post_assignment_codeÚ
free_temps)r~   rU   ÚtargetÚoverloaded_assignmentrÛ   r   r&   r&   r'   Úgenerate_assignment_code¬  s    



z%CArgDeclNode.generate_assignment_code)r   F)NF)rK   rk   rl   r‰   r¼   r  Úis_type_argÚ
is_genericÚkw_onlyÚnot_noneÚor_noner/   r)  rH  r@   Ú
is_dynamicrè   rG  rK  r”   rS  r&   r&   r&   r'   r=  H  s$   
.	
r=  c               @   s   e Zd Zdd„ ZdS )ÚCBaseTypeNodec             C   s
   |   |¡S )N)rè   )r~   rA   r&   r&   r'   r8   Ä  s    zCBaseTypeNode.analyse_as_typeN)rK   rk   rl   r8   r&   r&   r&   r'   rZ  ¼  s   rZ  c               @   s   e Zd Zg Zddd„ZdS )r?   Fc             C   s   | j S )N)r/   )r~   rA   r?  r&   r&   r'   rè   Í  s    zCAnalysedBaseTypeNode.analyseN)F)rK   rk   rl   r‰   rè   r&   r&   r&   r'   r?   È  s   r?   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 krp| j
rh|jrh|j}nt	}n| jrÌ|}x6| jD ],}| |¡}|d k	r¨|jr¨|jj}q‚d }P q‚W |d krÐ| | j| j¡}n|}|rr|jrä| ¡ }| | j¡}|d k	rúnx|r*| j
r|jr|j}nt	}t| jƒ| _nH| jr`| j| jkrRt| jd| j ƒ t | j¡}nt| jd| j ƒ |r”|jr”|jr”| |j¡}| jrÎ|jr¬|jr¸t| jdƒ t |¡}| |¡ n"|t j!krðtj"}| |¡ d| _|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)$rB  r
   Zsimple_c_typeÚsignedZlongnessr:   r   r%   Úmodule_pathr   r  r  r  Úlookuprñ   r/   r0  Úfind_imported_modulerÅ   Zlookup_typer   r@  r  r  râ   rã   rä   ÚcomplexÚ
is_numericÚ
is_complexZCComplexTypeZcreate_declaration_utility_coder   Zcomplex_typeZc_double_complex_typer   )r~   rA   r?  r/   r0  r   rÇ   r&   r&   r'   rè   á  sh    




zCSimpleBaseTypeNode.analyse)F)	rK   rk   rl   r‰   r@  r^  rB  ra  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} y| || j¡}W n< tk
rp } zt|j	|j
ƒ t ¡ | _| jS d }~X Y nX | | j|¡sˆt| _n&t ||¡| _| j | j¡ |  |¡ | jS )Nr   )Ú
MemoryView)rf  rè   r  r«   rh  Zget_axes_specsrg  r   r   ÚpositionZmessage_onlyr
   Z	ErrorTyper/   Zvalidate_axesr%   r   ZMemoryViewSliceTypeZvalidate_memslice_dtypeÚuse_memview_utilities)r~   rA   r?  rC   rh  Z
axes_specsÚer&   r&   r'   rè   4  s      

zMemoryViewSliceTypeNode.analysec             C   s   ddl m} | |j¡ d S )Nr   )rh  )r«   rh  Úuse_utility_codeÚview_utility_code)r~   rA   rh  r&   r&   r'   rj  K  s    z-MemoryViewSliceTypeNode.use_memview_utilitiesN)F)rK   rk   rl   r:   r‰   rè   rj  r&   r&   r&   r'   rd  /  s   
rd  c               @   s   e Zd ZdgZddd„ZdS )ÚCNestedBaseTypeNoderC   Nc             C   sr   | j  |¡}|tjkrtjS |js8t| jd| ƒ tjS |j | j	¡}|rP|j
slt| jd|| j	f ƒ tjS |jS )Nz'%s' is not a valid type scopez '%s.%s' is not a type identifier)rC   rè   r
   r   rñ   r   r%   r0  Úlookup_herer:   Úis_typer/   )r~   rA   r?  rC   Ú
type_entryr&   r&   r'   rè   X  s    

zCNestedBaseTypeNode.analyse)N)rK   rk   rl   r‰   rè   r&   r&   r&   r'   rn  P  s   rn  c               @   s*   e Zd ZddddgZdZdZd	dd„ZdS )
rE  rf  Úpositional_argsÚkeyword_argsÚ
dtype_nodeNFc             C   sÚ  |d kr| j  |¡}|jr|S |jr¤| ¡ r¤| jrP| jjrPt| jdƒ t	j
| _nPg }x:| jD ]0}| |¡}|d kr‚t|jdƒ t
}| |¡ q\W | | j|¡| _n|jr4ddlm} | | j|| j| j|j¡}tjd dk rötdd„ | ¡ D ƒƒ}t	j|f|Ž| _t|ƒr²t| jƒr²t	 t| jƒ| j¡| _n~t| jd	d d
}	t| jƒdk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:   r7   r&   r&   r'   rˆ   —  s   z-TemplatedTypeNode.analyse.<locals>.<listcomp>r«   )r:   r  zinvalid array declaration)rê   rî   )%rf  rè   r  rñ   rò   rs  r6   r   r%   r
   r   r/   rr  r8   r  rö   r;   r«   ru  Úanalyse_buffer_optionsÚbuffer_defaultsr   Úversion_inforb   rc   Z
BufferTyper   r!   ZPythranExprr    rÚ   rH   rí   rF  râ   rã   rä   )r~   rA   r?  rC   Útemplate_typesr  r/   ru  ÚoptionsZempty_declaratorrî   r&   r&   r'   rè   v  sZ     




zTemplatedTypeNode.analyse)FN)rK   rk   rl   r‰   rt  r:   rè   r&   r&   r&   r'   rE  f  s
   	rE  c               @   s   e Zd ZddgZddd„ZdS )ÚCComplexBaseTypeNoderC   r>  Fc             C   s$   | j  ||¡}| j ||¡\}}|S )N)rC   rè   r>  )r~   rA   r?  rê   Ú_r/   r&   r&   r'   rè   ½  s    zCComplexBaseTypeNode.analyseN)F)rK   rk   rl   r‰   rè   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 }x8| j D ].}| |¡}|jr0t|jdƒ tS | |¡ qW | | j|¡}d|_|j	S )Nz/Tuple types can't (yet) contain Python objects.T)
r~  rè   r;   r   r%   r   r  Zdeclare_tuple_typer7  r/   )r~   rA   r?  Zcomponent_typesrš   r/   rÇ   r&   r&   r'   rè   È  s    
zCTupleBaseTypeNode.analyseN)F)rK   rk   rl   r‰   rè   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~   rA   r/   rÇ   r&   r&   r'   r   á  s    
z"FusedTypeNode.analyse_declarationsFc             C   s`   g }xJ| j D ]@}| |¡}|s,t|jdƒ q||krBt|jdƒ q| |¡ qW tj|| jdS )Nz
Not a typezType specified multiple times)r:   )r`   r8   r   r%   r  r
   Ú	FusedTyper:   )r~   rA   r?  r`   r*  r/   r&   r&   r'   rè   è  s    
zFusedTypeNode.analyseN)F)rK   rk   rl   rx   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 )ÚCConstTypeNoderC   Fc             C   s*   | j  ||¡}|jr t| jdƒ t |¡S )Nz)Const base type cannot be a Python object)rC   rè   r;   r   r%   r
   r;  )r~   rA   r?  rê   r&   r&   r'   rè     s
    zCConstTypeNode.analyseN)F)rK   rk   rl   r‰   rè   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Ò   rC   ÚdeclaratorsNc             C   s  | j d kri | _ |s|}|| _| jr4| jd  ¡ }nd }|d k	rª| jdkrVt| jdƒ t| jƒdkrvt| jd jdƒ td|ƒ}|j	j
|_
x|D ]}| |j|| j¡ qW | j |¡}|jrÞ| jsÞ|jsÎ|jrÞt| jdƒ tS d | _| j}x,| jD ] }t| jƒdkr0t|tƒs0|j
d r0t|jd	dƒ | joH| jdkoH|j}|rVd
|_t|tƒr€|j||| j || jd\}	}
n|j|||| jd\}	}
|
 ¡ sÎ| jdkr¶|
jsÎ|
jsÎt|jd|
 ƒ | jdkrî|
jrît|jdƒ |	j}|	j}|dkrt|jdƒ d S |
jr4| jdkr4t|jdƒ |
j r²d|j
krNd|
_!|j"||
|j|| j| j| j#| j$| jd	| _| jd k	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ôW d S )Nr   r
  zOnly extern functions allowedr   z%Can't multiply declare template typesZfunc_templatezFused types not allowed herezwarn.multiple_declaratorsz‰Non-trivial type declarators in shared declaration (e.g. mix of pointers and values). Each pointer declaration should be on its own line.F)r'  ræ   rç   )ræ   rç   z Variable type '%s' is incompletez'Python object cannot be declared externr«   zMissing name in declaration.z8C++ references cannot be declared; use a pointer insteadrÏ   T)r  ræ   rç   ÚapiÚ	modifiersr&  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)r  ræ   rç   r„  Úis_cdef).r'  Ú
dest_scoperƒ  rØ   ræ   r   r%   rH   r   Úouter_scoperÀ   Zdeclare_typer:   rC   rè   râ   rç   r  Úis_module_scoper   rÇ   rI   rÚ   r   r&  rÿ   rû   rÞ   Úis_memoryviewslicer;   r  Zis_referenceró   Úis_static_methodÚdeclare_cfunctionr„  r…  r   r/   Úcreate_to_py_utility_codeÚcreate_wrapperr3  r   Ú
docstringsr.   r-   )r~   rA   r‡  r  Ztemplate_paramrC   ræ   r>  Zcreate_extern_wrapperr)  r/   r:   r  r&   r&   r'   r     sš    








z CVarDefNode.analyse_declarations)N)rK   rk   rl   r‰   Ú
decoratorsr'  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)
r5  r:   r/  r1  r%   r  ræ   r„  r“  rÇ   )r~   rA   r0  r&   r&   r'   Údeclare„  s    zCStructOrUnionDefNode.declarec             C   s¬   d }| j d k	rt| jƒ}|  ||¡ | j d k	r¨| jrB|jsBd| j_x| j D ]}| ||¡ qJW | j	dkr¨x>|j
D ]4}|j}x|jrŠ|j}q|W || jjkrpt|jdƒ qpW d S )Nr   r
  z)Struct cannot contain itself as a member.)r’  r   r:   r”  rç   rÔ   rÇ   r6  r   ræ   Úvar_entriesr/   rÞ   rC   r   r%   )r~   rA   r0  r˜   r/   r&   r&   r'   r   Š  s     




z*CStructOrUnionDefNode.analyse_declarationsc             C   s   | S )Nr&   )r~   rA   r&   r&   r'   rp   œ  s    z)CStructOrUnionDefNode.analyse_expressionsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rÄ   Ÿ  s    z-CStructOrUnionDefNode.generate_execution_code)N)rK   rk   rl   r‰   r”  r   rp   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 krd }nRdd„ | j D ƒ}tdd„ | j D ƒƒ}|rbtdd„ | j d | … D ƒƒsbt| jdƒ |j| jd | j| jg | j|d| _	d S )Nc             S   s   g | ]\}}t  || ¡‘qS r&   )r
   r  )r†   Útemplate_nameÚrequiredr&   r&   r'   rˆ   µ  s   z(CppClassNode.declare.<locals>.<listcomp>c             s   s   | ]\}}| V  qd S )Nr&   )r†   r|  r˜  r&   r&   r'   rÓ   ·  s    z'CppClassNode.declare.<locals>.<genexpr>c             s   s   | ]\}}|V  qd S )Nr&   )r†   r|  r˜  r&   r&   r'   rÓ   ¸  s    zGRequired template parameters must precede optional template parameters.)Úbase_classesræ   r  )
r  ÚsumrÕ   r   r%   Údeclare_cpp_classr:   r  ræ   rÇ   )r~   rA   ry  Znum_optional_templatesr&   r&   r'   r”  ±  s    

"zCppClassNode.declarec       
   	      s€  ˆj d krd  }}n dd„ ˆj D ƒ}dd„ ˆj D ƒ}d ‰ˆjd k	rRtˆjˆ |d‰‡fdd„}t|‡ ‡fdd„ˆjD ƒƒ}ˆ jˆjˆˆjˆj|ˆj	|dˆ_
ˆj
d krªd S d	ˆj
_ˆd k	rÄˆj
jˆ_g }‡fd
d„‰ˆjd k	rfˆjrôˆ jsôd	ˆj
_x4ˆjD ]*}t|dd ƒ}|r| ˆ¡ | ˆ¡ qüW x:ˆˆjƒD ],}	| |	¡ ˆj d k	r6dd |¡ |	_q6W tˆj|dˆ_ˆˆ_d S )Nc             S   s   g | ]\}}|‘qS r&   r&   )r†   r—  r|  r&   r&   r'   rˆ   Â  s    z5CppClassNode.analyse_declarations.<locals>.<listcomp>c             S   s   g | ]\}}t  || ¡‘qS r&   )r
   r  )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_class)r~   r&   r'   Úbase_okÈ  s    z2CppClassNode.analyse_declarations.<locals>.base_okc                s   g | ]}|  ˆpˆ ¡‘qS r&   )rè   )r†   Úb)rA   r0  r&   r'   rˆ   Í  s    )ræ   r  r   c             3   sJ   xD| D ]<}t |tƒr|V  qt |tƒrxˆ |jjƒD ]
}|V  q4W qW d S )N)rI   Ú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%   r  ræ   rÇ   rñ   r/   rç   rÔ   r6  rŠ   r”  r   r  r¡   Útemplate_declarationrÊ   r“   r0  )
r~   rA   ry  Ztemplate_namesr  Zbase_class_typesZdefined_funcsr˜   r”  rZ   r&   )rA   r   r0  r~   r'   r   ¾  sD    








z!CppClassNode.analyse_declarationsc             C   s   | j  | jjj¡| _ | S )N)r“   rp   rÇ   r/   r0  )r~   rA   r&   r&   r'   rp   í  s    z CppClassNode.analyse_expressionsc             C   s   | j  | jjj|¡ d S )N)r“   rÃ   rÇ   r/   r0  )r~   rA   rU   r&   r&   r'   rÃ   ñ  s    z*CppClassNode.generate_function_definitionsc             C   s   | j  |¡ d S )N)r“   rÄ   )r~   rU   r&   r&   r'   rÄ   ô  s    z$CppClassNode.generate_execution_codec             C   s   | j  |¡ d S )N)r“   r”   )r~   rU   r&   r&   r'   r”   ÷  s    zCppClassNode.annotate)
rK   rk   rl   r  r”  r   rp   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 )ÚCEnumDefNoderc   c          	   C   s,   |j | j| j| j| j| j| j| jd| _d S )N)r  r1  ræ   r„  rŽ  )	Zdeclare_enumr:   r%   r  r1  ræ   r„  rŽ  rÇ   )r~   rA   r&   r&   r'   r”    s
    zCEnumDefNode.declarec             C   s@   | j d k	r<| jr|jsd| j_x| j D ]}| || j¡ q&W d S )Nr   )rc   rç   rÔ   rÇ   r6  r   )r~   rA   r   r&   r&   r'   r     s
    
z!CEnumDefNode.analyse_declarationsc             C   s   | S )Nr&   )r~   rA   r&   r&   r'   rp     s    z CEnumDefNode.analyse_expressionsc          
   C   sª   | j dks| jr¦| | j¡ |jjtjdd}xj| jj	D ]^}| 
d||j| ||j¡f ¡ | |¡ | 
dtj|j|| |j¡f ¡ | |tj¡ q8W |j |¡ d S )NÚpublicT)Ú
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_valuesrO   r  Úerror_goto_if_nullÚ
put_gotrefr	   Zmoddict_cnamer:   Ú
error_gotoÚput_decref_clearÚrelease_temp)r~   rU   Útempr   r&   r&   r'   rÄ     s     
z$CEnumDefNode.generate_execution_codeN)rK   rk   rl   r‰   r”  r   rp   rÄ   r&   r&   r&   r'   r£  û  s
   r£  c               @   s   e Zd ZdgZdd„ ZdS )ÚCEnumDefItemNoder7   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 kd}|j |¡ |jr”|jj |j¡ d S )N)r  ræ   r„  rŽ  )r7   r÷   r/   rø   r"  r
   r=   Zdeclare_constr:   r%   r  ræ   r„  rŽ  r¨  r  rü   )r~   rA   Z
enum_entryrÇ   r&   r&   r'   r   3  s    
z%CEnumDefItemNode.analyse_declarationsN)rK   rk   rl   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 )
ÚCTypeDefNoderC   r>  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 )N)ræ   rç   )r  ræ   r„  Tr   )rC   rè   r>  ræ   rç   r:   r  r€  r%   r„  râ   rÔ   r6  )r~   rA   rê   r)  r/   r:   r  rÇ   r&   r&   r'   r   L  s    z!CTypeDefNode.analyse_declarationsc             C   s   | S )Nr&   )r~   rA   r&   r&   r'   rp   ]  s    z CTypeDefNode.analyse_expressionsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rÄ   `  s    z$CTypeDefNode.generate_execution_codeN)rK   rk   rl   r‰   r   rp   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   sz   d}xp| j D ]f}|jrVd}|jrB|j |¡|_|j |j|¡|_qrt|jdƒ d |_q|jrbd}q|rt|jdƒ qW d S )Nr   r   z)This argument cannot have a default valuez/Non-default argument following default argument)	rR   rÛ   rU  ro   r"  r/   r   r%   rV  )r~   rA   Zdefault_seenr9  r&   r&   r'   Úanalyse_default_values‡  s    z"FuncDefNode.analyse_default_valuesc             C   s2   |d krd S |j d r$| |¡d kr.| |¡}|S )NrA  )rÀ   r8   ro   )r~   rA   r@   r&   r&   r'   Úanalyse_annotation—  s
    
zFuncDefNode.analyse_annotationc             C   s*   x$| j D ]}|jr|  ||j¡|_qW d S )N)rR   r@   r³  )r~   rA   r9  r&   r&   r'   Úanalyse_annotationsŸ  s    zFuncDefNode.analyse_annotationsc             C   s¶   | j }|j}|j|kr,||j }| |¡}n<t|tƒrd|jrd|jd rd|j}| |¡}|d krh|S n|S |d kr~t	|j
dƒ n4|tk	r¬| |¡s¬t	|jj
dƒ t	|j
dƒ n||_|S )NrA  z
Not a typez2Signature does not agree with previous declarationzPrevious declaration here)r'  r/   r:   r8   rI   r=  r@   rÀ   rG  r   r%   r   r  rC   )r~   rA   r9  r'  Ú	orig_typer*  r+  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†   |}x|j s|jr|j}qW | jr<t| jj||| jjd}nt| jj||d}| j	|_	| jj
}|jrt|jop|j |_|| _|j|_|S )N)r:   rˆ  Úparent_scopeZ
scope_name)r:   rˆ  r¹  )Úis_py_class_scoper  rˆ  Úneeds_closurer   rÇ   r:   r  r   r   r/   ró   r  r  Úlocal_scoperÀ   )r~   rA   Úgenvr·  r/   r&   r&   r'   Úcreate_local_scope¾  s$    
zFuncDefNode.create_local_scopec             C   s   | j  |¡ d S )N)r“   rÄ   )r~   rA   rU   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k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 |}x|j(sž|jr¨|j)}qŽW | j*rÔ| +|j,j- .tj	¡¡ | #d¡ nP| j/r$|jr| +|j,j- .tj	¡¡ | #d¡ | +|j,j- .tj
¡¡ | #d¡ |  0||¡ x*|j1D ] }|j2s8|j3s8| 4|¡ q8W d}| jj5sª| jj6rzd}n| jjrŽd|j7 }| #d| j .tj8¡|f ¡ | 9¡ }|  :|¡ | j;}| j*pÎ| j/}x |j<D ]}|j-j6rØd}P qØW dd„ |j=D ƒ}|jo|j>o|p|}|jo0|j>o0| }|j p@|j>}|sN|r`| ?¡  d|j_n|jrx|j>rx| @¡  |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|¡}|s0d|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/rT| jUrö| #d ||j,j- N¡ tjVf ¡ n| #d!||j,j- N¡ tjVf ¡ |jr2| #dtj	|f ¡ n"| j*rT| Q||j,j-¡ | W|¡ |s`|r¦| jAsž| jXr~| jjd" }n| jj}|jY|| j!|jj d# d|j_Z|  [||¡ t\| t]ƒ}xx|j<D ]n}|j-j6rü|sèt^|j_ƒdkr0|j2s0| `|¡ n4|rÄ|j-jrÄt^|j_ƒdkrÄ|ja|jb|jjd$ qÄW xN|j1D ]D}|j3r>t^|j_ƒdkr>|j2s>|jcrv| d|¡ n
| `|¡ q>W x8|j1|j< D ](}|j-jer”|jfjgjhr”| i||¡ q”W |  j|¡ x*|j<D ] }|j-jerÒ| k||| j!¡ qÒW |r| l¡  d%|j_|  m||¡ |j | j!d%d& | #d¡ | #d'¡ | jjns¤| jj6rftj8}| o|| j¡ n>| jjp}|rŠ| #dtj8|f ¡ n| jj5s¤| #d(tj8 ¡ |jq|jrk	rÀ| jjnsÈ| s|jt¡ | u|jq¡ x,|j v¡ D ]\} }!|jw| |!|j d$ qàW t^|ƒd)k}"|"rn|j tx¡ | #d*¡ | #d+¡ | #d,¡ | #d-¡ x|D ]}| y||¡ qNW | #d.¡ | jjrŽ| ztj8|¡ tj8}#n|  {¡ }#|  |¡ }$|#d k	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 k	rH|%	rH|%}#|#d k		rt|#tj8k	rŽ| #dtj8|#f ¡ n| jj5	sŽ| #d(tj8 ¡ |	rž|  |¡ |"	s´|	s´| jj	rÀ| s|j¡ | u|jt¡ x|D ]}| y||¡ 	qÒW |	rø|  ‚|¡ | jj
rX| ƒ| j „tj8¡¡}&| #d1|& ¡ |j
r4| ?¡  | #d2¡ |j
rN| l¡  | #d¡ | u|j¡ x„|j1D ]z}|jh
rl|j2
r„
ql|j-j
r¤|j…|jb|j d$ n@|j-j6
rl|j3
rÆt^|j_ƒdk
rl|jc
rÚ| †|¡ n
| ‡|¡ 
qlW xx|j<D ]n}|j-j6r*|st^|j_ƒdkr^|j2s^| ‡|¡ n4|j-j
rò|rJt^|j_ƒdk
rò|j…|jb|j d$ 
qòW | j*r~| ˆtj	|j,j-¡ |jsÈ| jjp}%|  {¡ }#|#d krª|%rª|%}#| jj6rÈ| ‰| j Štj8¡¡ | jj‹rö| jjd3krö| #d4tj8tj8f ¡ |s|rHd%|j_Z| jAsH| jj6r4|jŒtj8|jj d# n|jŒd|jj d# |jsX| ¡  |sn|jr~|j>r~| l¡  d%|j_| jj5s˜| #d5tj8 ¡ | #d¡ |
r¶| #d6|
 ¡ | Ž|j¡ | ¡  | j&rà| j& ||¡ |  |¡ d S )7Nr   )ru  )rh  z%s->%sÚ__getbuffer__Ú__releasebuffer__Zcython_unusedÚprofileÚ	linetraceZProfilez	Profile.cr«   T)Úwith_pymethdefÚ
proto_only)rÄ  ú;z = NULLz = z%s%s;c             S   s   g | ]}|j r|‘qS r&   )r7  )r†   rÇ   r&   r&   r'   rˆ   =  s    z=FuncDefNode.generate_function_definitions.<locals>.<listcomp>)Úacquire_gilZtp_newre   z
%s->tp_newz%s = (%s)%s(%s, %s, NULL);zif (unlikely(!%s)) {z%s = %s;ÚPy_Nonez} else {Ú}z*%s = (%s) __Pyx_CyFunction_GetClosure(%s);z%s = (%s) %s;z
 (wrapper))r  )Úhave_gilF)Útracez/* 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'.z	if (%s) {zOPyErr_SetString(PyExc_TypeError, "Memoryview return value is not initialized");Ú__hash__z5if (unlikely(%s == -1) && !PyErr_Occurred()) %s = -2;z
return %s;z#endif /*!(%s)*/)‘r«   ru  r   rŠ  rh  r¼  Úis_closure_scopeZis_passthroughr	   Úcur_scope_cnameÚouter_scope_cnameZmangle_closure_cnamesr“   rÃ   rÉ   rÇ   r:   r0  r  r…  Úget_preprocessor_guardrÂ   rÀ   rl  r   Úload_cachedÚenter_cfunc_scopeÚ	new_labelÚreturn_from_error_cleanup_labelr  r¦  Ú	gil_ownedrÎ   r%   rÈ   rO   Úneeds_assignment_synthesisÚpymethdef_requiredÚpy_funcÚgenerate_function_headerrº  rˆ  r»  ÚputÚscope_classr/   rá   Úneeds_outer_scopeÚgenerate_argument_declarationsr•  Ú
in_closurer4   Ú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_cnamerC  Úempty_tuplerJ  Ú
put_increfr   r«  rª  Úis_cyfunctionÚ
self_cnamerN  rº   Úput_trace_callÚ	can_traceÚgenerate_argument_parsing_coderI   rŸ  rH   Úcf_assignmentsÚput_var_increfÚput_incref_memoryviewslicer  Úxdecref_cleanupÚput_var_xincrefrß   Z
buffer_auxZbuflocal_nd_varr7  Zput_init_varsÚgenerate_argument_type_testsZput_acquire_arg_bufferÚput_release_ensured_gilr¿  r¹   Úput_init_to_py_nonerH  Ú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~   rA   rU   ru  rh  r·  rÒ  Zis_getbuffer_slotZis_releasebuffer_slotZis_buffer_slotÚpreprocessor_guardrÂ  rÃ  rÄ  ÚcenvrÇ   ÚinitÚtempvardecl_coderÇ  Zhave_object_argsr9  Zused_buffer_entriesZacquire_gil_for_var_decls_onlyZacquire_gil_for_refnanny_onlyZuse_refnannyrì  Ztp_slotZslot_func_cnameZ
trace_namer†  ÚlhsÚvalr  r/   Zbuffers_presentÚerr_valr-  Zdefault_retvalÚcondr&   r&   r'   rÃ   Ö  sF   





























  






























z)FuncDefNode.generate_function_definitionsc             C   sh   |j jrt|jdƒ n,|j  ¡ sB|j jsB|j jsBt|jd|j  ƒ | |j|j |j¡}|j	rd|j	|_	|S )NzInvalid use of 'void'z Argument type '%s' is incomplete)
r/   rà   r   r%   rû   rÞ   rŠ  Zdeclare_argr:   r@   )r~   rA   r9  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ArgTypeTestzFunctionArguments.cz((PyObject *)%s)z:if (unlikely(!__Pyx_ArgTypeTest(%s, %s, %d, "%s", %s))) %szICannot test type of extern C class without type object name specification)r/   Ztypeobj_is_availablerÂ   rl  r   rÔ  ró  rÇ   r  rO   Úaccept_noner:   Úis_builtin_typeZrequire_exactr«  r%   r   )r~   r9  rU   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É  )
r/   rŠ  rÇ   r  rO   r–   rH   r:   r«  r%   )r~   r9  rU   r  r&   r&   r'   Úgenerate_arg_none_checkŸ  s    z#FuncDefNode.generate_arg_none_checkc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   r  ¬  s    z&FuncDefNode.generate_wrapper_functionsc             C   s0   |  | j¡ x| jD ]}|js| |¡ qW d S )N)rÎ   r%   rR   rY  rS  )r~   rU   r9  r&   r&   r'   rÄ   ¯  s    z#FuncDefNode.generate_execution_codec          	   C   sH   | j jd }y|jjjjd j}W n ttfk
r>   d }Y nX ||fS )Nr   Úobj)r¼  ræ  r/   rC   r0  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É  )r0  r  rO   )r~   rU   r.  r|  Úviewr&   r&   r'   rï  É  s    

zFuncDefNode.getbuffer_checkc             C   sN   |   ¡ \}}|j}|r<|jr<| d| |¡ | d| ¡ n| d| ¡ d S )Nz%s->objz%s->obj = NULL;)r0  r  r;   r  rN  rO   )r~   rU   r.  r/  r1  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) {z%s->objrÉ  zPy_CLEAR(%s->obj);)r0  r  r;   rO   rª  r¬  )r~   rU   r.  r/  r1  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) {z%s->objrÉ  )r0  r  r;   rO   rª  r¬  )r~   rU   r.  r/  r1  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krX| j jjrXd S | 	¡ S )NZ__long__Ú__int__)rÀ  rÁ  )
rÇ   r  r:   r   Úmethod_name_to_slotÚgetr0  ro  r  Úpreprocessor_guard_code)r~   r:   Úslotr&   r&   r'   rÓ  ï  s    z"FuncDefNode.get_preprocessor_guard)#rK   rk   rl   rÛ  r»  rß  rÚ  rê  Úis_generator_bodyZis_async_defr…  Úhas_fused_argumentsÚstar_argÚstarstar_argrö  rì  r²  r³  r´  r¶  r¸  r¾  r¿  rÃ   r%  r)  r+  r  rÄ   r0  rï  rò  r  r  rÓ  r&   r&   r&   r'   r±  d  sF      0

			r±  c                   sò   e Zd Zddddg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d3dd„Zdd„ Zdd„ Zdd„ Zdd„ Zd4dd„Zd5d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/d0„ Z d1d2„ Z!‡  Z"S )6rŸ  rC   r>  r“   Úpy_func_statFNc             C   s   | j jS )N)rÇ   r:   )r~   r&   r&   r'   Úunqualified_name 	  s    zCFuncDefNode.unqualified_namec             C   s   | j r| j jS d S )N)rÛ  rì  )r~   r&   r&   r'   rì  #	  s    zCFuncDefNode.code_objectc             C   sR  |j | _| jd kri | _| j |j di ¡¡ | jd k	rb| j |¡}|d krnt| jj	dƒ t
j}n| j |¡}d|jko‚| d¡ | _t| jtƒr¼| jj||d| jd k	 | j| jd\}}n$| jj||d| jd k	 | jd\}}|jsòt| j	dƒ || _| j|_| j}xt|dƒs|j}qW || _|j| _| jj}| jd	ksJ| jr^|r^t| jj	d
ƒ |jdkr„| jdkr„t | jj	dƒ xÌt!| j|jƒD ]º\}}|  "||¡ |j|_|j#|_#|j$|_$|  %|j|j	|¡ |jj&râd| _'|jj(rd| j)krt |j	ddƒ |jj(s|jj*r”| jj+r2t|j	dƒ nd| j)kr”t |j	ddƒ q”W |  %|j,| j	|¡ |j#}	|j$}
| j-|_-| j|_|j.|	|| j	|
| j| j| jd k	| 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r:|j5s:| js:t6| jƒdk s4| jd jj7s:d| _|  8|¡ |  9|¡ d S )NÚlocalsz
Not a typerÏ   r"   )rå   r'  ræ   )rå   ræ   z*Suite attached to non-function declarationrR   r¤  zBFunction with optional arguments may not be declared public or apir  r
  z/Only extern functions can throw C++ exceptions.TÚinlinez$Buffer unpacking not optimized away.r   zUBuffer may not be acquired without the GIL. Consider using memoryview slices instead.)r  ræ   r„  Údefiningr…  r&  zFunction cannot return an arrayzused as a return valuer   F):r  Úis_c_class_methodr'  r}   rÀ   r4  Údirective_returnsr8   r   r%   r
   r   rC   rè   ro  r‹  rI   r>  rÿ   r“   ræ   ró   r/   r&  r  rD  rê   Zcfunc_declaratorrR   r  r„  r  r   Úzipr¶  r:   r  Ú_validate_type_visibilityrâ   r8  rß   r…  Úis_pythran_exprr  r   r  rŒ  rÇ   Úinline_in_pxdZinline_func_in_pxdrÞ   rñ   Zcheck_nullary_constructorr‰  rH   r;   Údeclare_cpdef_wrapperr¾  )r~   rA   rC   r)  r/   r>  Zopt_arg_countÚ
formal_argÚtype_argr:   r  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:   rR   r9  r:  r-   r“   r  rº   T)rË   )rÛ  )!r&  r‹  r   r%   rÇ   r:   Úcall_self_noder‰  rô   r  ÚDecoratorNoderI  ro   ÚDefNoderR   r-   rÛ  r   r  rÊ   r;  r
   r   r/   Úas_variabler7  rÆ   Úis_final_cmethodr   Úlookup_module_cpdefÚOverrideCheckNodeÚoverrider“   )r~   rA   r:   Zpy_func_bodyr  r  r&   r&   r'   rF  …	  s>    




z"CFuncDefNode.declare_cpdef_wrapperc             C   sN   | j dkp| j}t|ddƒ}|rJ|rJ|jrJ|j dksJ|jsJ|jsJt|dƒ dS )zo
        Ensure that types used in cdef functions are public or api, or
        defined in a C header.
        r¤  rÇ   N)r¤  r
  z:Function declared public or api may not have private types)ræ   r„  rŠ   r‰  rÔ   r   )r~   r/   r%   rA   Zpublic_or_apirÇ   r&   r&   r'   rC  ©	  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†   r9  r&   r&   r'   rˆ   º	  s    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ˆ   Ð	  s    )ÚfunctionrR   Zwrapper_call)r%   r   r7   )r«   rô   r/   rR   rH   r  r  r%   rÇ   r:   r   rO  r‹  r0  r  ZAttributeNodeÚSimpleCallNodeÚReturnStatNoder
   r   )r~   Zomit_optional_argsr‰  rR   Ú	arg_namesÚcfuncZcall_arg_namesZskip_dispatchZclass_entryZ
class_noderq  rH  Zc_callr&   )rô   r~   r'   rJ  µ	  s4    zCFuncDefNode.call_self_nodec             C   s4   x.| j jD ]"}|js t|jdƒ |  ||¡ q
W d S )NzMissing argument name)r/   rR   r:   r   r%   r%  )r~   rA   r9  r&   r&   r'   Údeclare_argumentsÔ	  s    zCFuncDefNode.declare_argumentsc             C   s   | j jS )N)r/   r  )r~   r·  r&   r&   r'   r¸  Ú	  s    z!CFuncDefNode.need_gil_acquisitionc             C   sZ   | j }|j}|jrV|sV|jjr*t| jdƒ x*| jjD ]}|j jr4|j	s4t| jdƒ q4W d S )Nz9Function with Python return type cannot be declared nogilz8Function declared nogil has Python locals or temporaries)
r/   r  r  r   r;   r   r%   r¼  r•  Zin_with_gil_block)r~   rA   r/   r  rÇ   r&   r&   r'   r½   Ý	  s    
zCFuncDefNode.nogil_checkc             C   sd   |j | j_ | jd k	r$| j |¡| _n.| jd k	r>| j |¡| _n|  |¡ |  |¡ |  | j¡| _| S )N)	rÀ   r¼  r;  rp   rÛ  r²  r´  r¸  rÇ  )r~   rA   r&   r&   r'   rp   è	  s    




z CFuncDefNode.analyse_expressionsc             C   s   dS )NFr&   )r~   rA   rU   r&   r&   r'   rÙ  ö	  s    z'CFuncDefNode.needs_assignment_synthesisr   c             C   s¤  | j }g }| j}xN|jd t|jƒ|j … D ]0}	|	 ¡ }
| |	j¡}|jsRd|
 }
| 	|
¡ q,W |r˜| j
r˜tj tj¡}| jrŠ| 	|¡ n| 	d| ¡ |jr¶|r¶| 	|j tj¡¡ |jrÆ| 	d¡ |sÐdg}|d krà| jj}| |d |¡¡}| jjdkrd|krd}nd}d }| | jj¡}| jj||d	}| j}| jrj|r^|jjd
  | j¡ | | j¡ |rŒ|jjd
  d|||f ¡ | d|||f ¡ d S )NzCYTHON_UNUSED %sz...Úvoidz, Úprivatez::zstatic r«   )Údll_linkageZmodule_declarationsz%s%s%s; /* proto*/z%s%s%s {) r¼  r/   rR   rH   r  rá   r_  r:   Úcf_usedr  r&  r
   r=   r	   Úskip_dispatch_cnamerQ  r8  Úoptional_args_cnamer%  rÇ   Ú
func_cnameZfunction_header_coder¡   ræ   Zbuild_function_modifiersZfunc_modifiersr   r@  r¢  rÂ   ÚpartsrO   )r~   rU   rÄ  Úwith_opt_argsÚwith_dispatchr  r0  Z	arg_declsr/   r9  Zarg_declrÇ   Zdispatch_argÚentityZstorage_classr\  r…  ÚheaderZneeds_protor&   r&   r'   rÜ  ù	  sN     


z%CFuncDefNode.generate_function_headerc             C   s^   | j }xR| jD ]H}|jr| |j¡}| js0|jr| |¡}| d|j	 
|j¡|f ¡ qW d S )Nz%s = %s;)r¼  rR   rÛ   r_  r:   rQ  r]  rK  rO   r/   rá   r  )r~   rA   rU   r0  r9  rÇ   r   r&   r&   r'   rà  &
  s    
z+CFuncDefNode.generate_argument_declarationsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rå  0
  s    z"CFuncDefNode.generate_keyword_listc       
   	      s  d}d}| j }| jjràˆ dtj ¡ x’| jD ]ˆ‰ ˆ jr.| ˆ j	¡}| j
sP|jr®ˆ dtjtj|f ¡ ˆ j}xt|dƒs‚|j}qpW ˆ dˆ jtj| j |j	¡f ¡ |d7 }|d7 }q.W xt|ƒD ]}ˆ d¡ qÄW ˆ d¡ ‡ ‡fdd	„}	x| jD ]‰ |	| ˆ j	¡ƒ qöW d S )
Nr   z	if (%s) {zif (%s->%sn > %s) {r:   z%s = %s->%s;r   rÉ  c                sT   | j rPˆ jsPˆ d| j| jf ¡ | jjr<ˆj| jdd nˆ | ¡ ˆ 	| ¡ d S )Nz%s = %s;T)rÊ  )
rá  rÛ   rO   r  Úoriginal_cnamer/   rŠ  rý  rü  Úput_var_giveref)rÇ   )r9  rU   r&   r'   Úput_into_closureM
  s    
zECFuncDefNode.generate_argument_parsing_code.<locals>.put_into_closure)r¼  r/   r  rO   r	   r_  rR   rÛ   r_  r:   rQ  r]  r2  r>  rD  rê   r  Zopt_arg_cnameÚrangero  )
r~   rA   rU   r(  r7  r0  rÇ   r>  r|  rh  r&   )r9  rU   r'   rú  3
  s4    

z+CFuncDefNode.generate_argument_parsing_codec             C   s   d S )Nr&   )r~   rU   r&   r&   r'   Ú!generate_argument_conversion_codeY
  s    z.CFuncDefNode.generate_argument_conversion_codec             C   sD   x>| j jD ]2}|jr"|  ||¡ q
|j jr
|js
|  ||¡ q
W d S )N)r/   rR   Úneeds_type_testr)  r;   r&  r+  )r~   rU   r9  r&   r&   r'   r   \
  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%   rO   rd   rŸ  rÄ   r;  )r~   rU   )rJ   r&   r'   rÄ   e
  s    
z$CFuncDefNode.generate_execution_codec             C   s   | j jrdS | jjjS d S )NÚ0)r   r;   rÇ   r/   r   )r~   r&   r&   r'   r  m
  s    zCFuncDefNode.error_valuec             C   s
   | j jjS )N)rÇ   r/   r  )r~   r&   r&   r'   r  t
  s    z)CFuncDefNode.caller_will_check_exceptionsc             C   s   d}| j }|j}x|jd k	r|d7 }|j}d| j jtj|f |_| ¡  | j|d|jj|jj	|jd | j
js|| d¡ | jj}dd„ |d t|ƒ| jj	 … D ƒ}|jjr¼| tj¡ n|jrÌ| d¡ |jj	râ| tj¡ n|j	rò| d	¡ | d
| j jd |¡f ¡ | d¡ qW d S )Nr   r   z%s%swrap_%s)rc  rb  r  zreturn c             S   s   g | ]
}|j ‘qS r&   )r  )r†   r9  r&   r&   r'   rˆ   Š
  s    z;CFuncDefNode.generate_wrapper_functions.<locals>.<listcomp>rl  ÚNULLz%s(%s);z, rÉ  )rÇ   r/   Z
prev_entryr`  r	   r2  rO   rÜ  r  r  r   rà   rÝ  rR   rH   r  r^  r_  r¡   )r~   rU   ÚkrÇ   r  rR   Zarglistr&   r&   r'   r  w
  s6    

"

z'CFuncDefNode.generate_wrapper_functions)r   r   )N)r   r   N)#rK   rk   rl   r‰   rE  r  r'  rA  rQ  r¢  r  r;  r<  Úpropertyrì  r   rF  rC  rJ  rY  r¸  r½   rp   rÙ  rÜ  rà  rå  rú  rj  r   rÄ   r  r  r  rm   r&   r&   )rJ   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 )N)rÇ   rÃ   )r~   rA   rU   r&   r&   r'   rÃ   ¢
  s    z+PyArgDeclNode.generate_function_definitionsN)rK   rk   rl   r‰   r  rT  rÃ   r&   r&   r&   r'   rp  —
  s   rp  c               @   s   e Zd ZdgZdS )rK  rI  N)rK   rk   rl   r‰   r&   r&   r&   r'   rK  ¦
  s   rK  c               @   s&  e Zd ZddddddgZddgZdZdZdZd	Zd
Z	d
Z
dZdZdZd
Zd
ZdZdZdZdZdZdZdZdZdZdZdd„ Zd6dd„Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Z dd„ Z!dd„ Z"dd„ Z#d d!„ Z$d"d#„ Z%d7d$d%„Z&d&d'„ Z'd(d)„ Z(d*d+„ Z)d8d,d-„Z*d.d/„ Z+d0d1„ Z,d2d3„ Z-d4d5„ Z.dS )9rL  rR   r9  r:  r“   r  Úreturn_type_annotationFNrl  r   Tc             K   sl   t j| |f|Ž d } }}x8| jD ].}|jrD|d7 }|jsD|d7 }|js$|d7 }q$W || _|| _|| _d S )Nr   r   )r±  r€   rR   rV  rÛ   Únum_kwonly_argsÚnum_required_kw_argsÚnum_required_args)r~   r%   rS   rn  ZrkÚrr9  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 kr¬g }x@| jD ]6}|j|dd\}}| tj|j	d |j
t|jd¡ qHW tjt|dd |
|||d}t| j|d	}n°|d krº|j}|j}t| jƒt|jƒksÚ|jròt| jd
ƒ t|jdƒ xhtt| j|jƒƒD ]R\}\}}|j|d|dko(|jd\}}|d ksH|tjkr|j|_||_qW |	d kr’|jd k	r’ddlm} || j|j|jd}	t| jt| j| j	d d| jd|j|	|j|jd}t| j|pÐg t | j|jd	|| j!| j"|j#||j|jddt$|di ƒ|dS )Nz'cdef function cannot have star argumentz+cdef function cannot have starstar argument)NFr   )rå   )r:   r  r@   r/   r%   F)r   rR   r%  r   r  r  r  r  )r/   zwrong number of argumentszprevious declaration herer   )rå   r  )r  )r7   r/   )r:   r  )rê   rR   r%  r  r   r  r  r[  r'  )r…  rC   r>  r“   r-   r&  r/   r  r  ræ   r„  r'  rA  )%r9  r   r%   r:  rR   rè   r  r
   r  r:   r@   r   r$  rÒ   r0  r/   rH   r%  r  rB  r  r)  r   rô   r  r   rÿ   rÚ   r  r  r  rŸ  r?   r“   r-   r  rŠ   )r~   rX  r0  r&  ZreturnsZ
except_valr…  r  r  r   r  Z
cfunc_argsrG  r)  r/   Z
cfunc_typer(  rH  r  r>  r&   r&   r'   Úas_cfunctioní
  sz     

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»  r9  r:  )r~   r&   r&   r'   Úis_cdef_func_compatible0  s
    zDefNode.is_cdef_func_compatiblec          	   C   s\  | j rJxB| j D ]8}|j}|jr|  j|jdkO  _|  j|jdkO  _qW | jr`| d¡r`d| _| jrv| d¡rvd| _| jdkrŒ|jrŒd| _|  |¡ | jdkr¬|  	|¡ n
|  
|¡ |  |¡ | jj ¡ | _| jtk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Ï   Fre   r   z<lambda>rA  )rQ  r:   rR   r9  r:  r   )r  rI  r9   Úis_classmethodr:   Úis_staticmethodro  rº  Úanalyse_argument_typesÚdeclare_lambda_functionÚdeclare_pyfunctionÚanalyse_signaturerÇ   Ú	signaturer   r   rq  rÀ   r  rE   r;   r¾  ÚDefNodeWrapperr%   rR   r9  r:  Ú
py_wrapperr   )r~   rA   rI  rZ   r|  r   r&   r&   r'   r   ;  sB    




zDefNode.analyse_declarationsc             C   sÔ  |j  di ¡| _|j d }|j}d |_xx| jD ]l}t|dƒrFd }nV|j |¡}t|ƒrp|j	rpt
 ||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rr|jrd|_nd|j rd|_nT|jj!sD|jj"sD|jjsD|jjrj|j#rb|j#j$d krbd|_n||_nd|_q0d|_|j rŒt|jd	ƒ |jr0t|jd
ƒ q0W ||_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&   )r/   Zis_numpy_buffer)r†   r(  Úar&   r&   r'   rˆ   ¤  s    z2DefNode.analyse_argument_types.<locals>.<listcomp>)'rÀ   r4  r'  rã   rR   rD  rC   rè   r   rD  r
   r  Z
org_bufferr>  r:   r/   râ   r8  r¶  r  r   r%   Zas_argument_typeÚhdr_typeÚneeds_conversionrk  rU  r;   rß   rŠ  rX  r&  rW  Úis_extension_typer'  rÛ   Úconstant_resultr  Únp_args_idx)r~   rA   r‚  Zf2sr9  r)  rC   r/   r&   r&   r'   r{  h  sZ    




zDefNode.analyse_argument_typesc             C   s2  | 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kr¶t| jƒdkr€tj| j _n4t| jƒdkr´| jd jd kr´| jd js´tj| j _nd| j jtjkrt| jƒdkràtj| j _n:t| jƒdkr| jd jd kr| jd jstj| j _| j j}| ¡ }|tjk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 …= xàt t!|t| jƒƒƒD ]È}| j| }d|_"| #|¡rT| jsT| jr8d|_$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òW |t| jƒkrÚ|  4¡  d S |t| jƒk r.|jsú|  4¡  x2| jD ](}|j"r|j(j5s"|j(j6rd|_.qW d S )Nz8special functions of cdef classes cannot have decoratorsr   Zalways_allow_keywordsr   r"   Tr  )7rÇ   r  r  r   r%   rH   rR   r9  r:  Ztrivial_signaturerÀ   r  r   Zpyfunction_signatureZpyfunction_noargsrÛ   rV  Zpyfunction_oneargZpymethod_signatureZ	unaryfuncZibinaryfuncÚnum_fixed_argsÚself_in_starargrz  r  r   Zfixed_arg_formatÚhas_generic_argsry  r8  Zdecorator_indirectionrË   ri  ÚminrU  r  rT  r   Z	type_typer„  r/   r  r…  Zfixed_arg_typer  r;   rk  r	   Z
arg_prefixr:   Ú	hdr_cnameZ
var_prefixÚbad_signaturer†  r'  )r~   rA   ÚsigZnfixedr(  r9  r&   r&   r'   r~  ¨  sz    " 

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 methodÚMethodz>%s %s has wrong number of arguments (%d declared, %s expected))rÇ   r  r‰  r‹  r:   Ú
startswithÚendswithr   r%   rH   rR   )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ksÜ|jrÜ|j dk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:   ro  rN  r  Úis_final_typer   r%   r/   ró   Zis_builtin_cmethodrº   r   r}  rÇ   Únext_idÚscope_prefixr	   Zpyfunc_prefixÚpyfunc_cnamer   r  r.   r-   Zfuncdoc_prefixÚ	doc_cnamer  r   Z	invisiblerÀ   Úwrapperbase_cnameZwrapperbase_prefix)r~   rA   r:   rÇ   Úprefixr&   r&   r'   r}    s(    
zDefNode.declare_pyfunctionc             C   s*   |  | j| j¡}d |_|| _|j| j_d S )N)r|  Úlambda_namer%   r-   rÇ   r  rš  )r~   rA   rÇ   r&   r&   r'   r|    s    zDefNode.declare_lambda_functionc             C   s˜   xv| j D ]l}|jst|jdƒ |jrL| |j|j|j¡|_|jjrZd|j_	n|  
||¡|_d|j_d|j_|j|j_qW |  || j¡ |  || j¡ d S )NzMissing argument namerl  r   )rR   r:   r   r%   r…  r3  r/   rÇ   r;   r  r%  r4   r7  r  Údeclare_python_argr9  r:  )r~   rA   r9  r&   r&   r'   rY  !  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   rl  )rÀ   r
   Zunspecified_typer   r3  r:   r%   r4   r7  r  rþ  rÇ   )r~   rA   r9  r/   rÇ   r&   r&   r'   rŸ  1  s    zDefNode.declare_python_argc             C   s|   |j | j_ |  |¡ |  |¡ | jr4|  || j¡| _|  |¡sl| jrlx&| jd d d… D ]}|j 	|¡|_qVW | j
 |¡ | S )Nr®   )rÀ   r¼  r²  r´  rq  r³  rÙ  r  rI  rp   r  Úprepare_argument_coercion)r~   rA   rI  r&   r&   r'   rp   >  s    


zDefNode.analyse_expressionsc             C   sv   | j r
dS | js| jjrdS | jr&dS | jjr2dS | jjr>dS |jsJ|jrj|d kr^| j	j
d S |jj
d S |jpt|jS )NTFZbinding)rz  Úspecialized_cpdefsrÇ   Zis_fused_specializedÚno_assignment_synthesisr  Zis_anonymousr‰  r  r¼  rÀ   rÂ   rº  rÐ  )r~   rA   rU   r&   r&   r'   rÙ  L  s    z"DefNode.needs_assignment_synthesisc             C   s
   | j jjS )N)rÇ   r  r  )r~   r&   r&   r'   r  ^  s    zDefNode.error_valuec             C   s
   | j jjS )N)rÇ   r  r  )r~   r&   r&   r'   r  a  s    z$DefNode.caller_will_check_exceptionsc             C   sJ   | j r| j  | ¡ |¡ | jr8| jj| j_| j ||¡ t | ||¡ d S )N)Údefaults_getterrÃ   rÅ   Úpy_wrapper_requiredrÇ   r`  r  r±  )r~   rA   rU   r&   r&   r'   rÃ   d  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„ }x| j
D ]}| 	||ƒ¡ q^W | jrŠ| 	|| jƒ¡ | jr | 	|| jƒ¡ |r°d |¡}nd}| j | jj¡}	|jd }
|  ¡ }|rä|
 |¡ |
 d	|	|f ¡ |r|
 d
¡ | d|	|f ¡ d S )NTzPyObject *%szCYTHON_UNUSED c             S   s8   | j }|jr|j}n|j}|j |¡}|js4d| }|S )NzCYTHON_UNUSED )rÇ   rá  rf  r  r/   rá   r]  )r9  rÇ   r  Údeclr&   r&   r'   Úarg_decl_code}  s    z7DefNode.generate_function_header.<locals>.arg_decl_codez, rZ  Zdeclszstatic %s(%s); /* proto */z#endifzstatic %s(%s) {)r¤  r  rÜ  rÇ   r  Úhas_dummy_argr	   r÷  rß  r  rR   r9  r:  r¡   r   rá   rš  rÂ   rÓ  rO   )r~   rU   rÄ  rÅ  Úarg_code_listÚself_argr¦  r9  r(  ÚdcZ
decls_coder  r&   r&   r'   rÜ  p  s>    






z DefNode.generate_function_headerc             C   s   d S )Nr&   )r~   rA   rU   r&   r&   r'   rà  ž  s    z&DefNode.generate_argument_declarationsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rå  ¡  s    zDefNode.generate_keyword_listc                sN   ‡ fdd„}x| j D ]}||jƒ qW x"| j| jfD ]}|r4||jƒ q4W d S )Nc                sP   | j rLˆ  d| j| jf ¡ | jr8ˆ  | ¡ ˆ  | ¡ nˆ  | ¡ ˆ  | ¡ d S )Nz%s = %s;)	rá  rO   r  rf  rþ  rÿ  Zput_var_xgiverefrü  rg  )rÇ   )rU   r&   r'   rh  ¦  s    

z@DefNode.generate_argument_parsing_code.<locals>.put_into_closure)rR   rÇ   r9  r:  )r~   rA   rU   rh  r9  r&   )rU   r'   rú  ¤  s    z&DefNode.generate_argument_parsing_codec             C   s   d S )Nr&   )r~   rU   r&   r&   r'   r   ·  s    z$DefNode.generate_argument_type_tests)NNTNNNFF)N)r   )/rK   rk   rl   r‰   r¼   rz  ry  rž  Zreqd_kw_flags_cnamerº   r¢  r  rq  rÇ   rÇ  rŠ  Zpy_cfunc_nodeÚrequires_classobjÚdefaults_structr-   Úfused_py_funcr¡  r  r¤  r`  r£  r€   rv  rw  r   r{  r~  rŽ  r}  r|  rY  rŸ  rp   rÙ  r  r  rÃ   rÜ  rà  rå  rú  r   r&   r&   r&   r'   rL  ­
  sZ    
B-@M

.rL  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   sD   t j| f|ž|Ž | jj| _| jj| _| jj| _| jj| _d | _d S )N)r±  r€   rQ  rr  rs  rt  rŠ  r  )r~   rR   rs   r&   r&   r'   r€   Á  s    



zDefNodeWrapper.__init__c             C   sP   | j j}| j}| |j¡}tj| | |_tj| | |_	|j
| _
| j j| _d S )N)rQ  rÇ   r:   r˜  r™  r	   Zpywrap_prefixr`  Zpymethdef_prefixÚpymethdef_cnamer  rˆ  )r~   rA   Ztarget_entryr:   r  r&   r&   r'   r   É  s    z#DefNodeWrapper.analyse_declarationsc             C   sˆ   x>| j D ]4}|jjs"|j |¡s<q|jr|jjs|j |¡sqW | jr„| jjjs„| jj}d|_	x$|j
D ]}|jsf|jjrfd|j_qfW d S )Nr   T)rR   r/   r;   Úcreate_from_py_utility_coder„  r  r:  rÇ   r]  rþ  rû  r4   r!  r9   Zcf_maybe_null)r~   rA   r9  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 )Nr   r   )rH   rR   r  rT  )r~   Zargcountr&   r&   r'   Úsignature_has_nongeneric_argsê  s    
z,DefNodeWrapper.signature_has_nongeneric_argsc             C   s   | j jS )N)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¡ xR| jD ]H}|jrZ|jjsZ|jj	sZ|jj
sZ| |j |jj¡¡ q | |jj¡ q W | jr‚| | jjj¡ | jr˜| | jjj¡ d |¡}| jjsº| dtj ¡ | d| jjj|f ¡ d S )Nz, z%s = z%s(%s);)r  r§  r  r	   r÷  rR   r„  r/   rŠ  rœ  rc  rJ  rÇ   r  r9  r:  r¡   r   rà   rÝ  rã  rO   rQ  rš  )r~   rU   rR   r9  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kr–| |j¡ |  |j¡ x$|j !¡ D ]\}}	| "||	¡ qVW |  #¡ }
|
d k	r–| dtj|
f ¡ |  |j¡ x,|j$D ]"}|j%rª|j&jrª| '|¡ qªW | (¡  | jjsò| dtj ¡ | d	¡ | )¡  |r| d
| ¡ d S )Nr«   z/* Python wrapper */z = 0z%s%s;z%s (wrapper)z/* function exit code */z%s = %s;z
return %s;rÉ  z#endif /*!(%s)*/)*rQ  r¼  rÎ   r%   rO   rÓ  rÕ  rÖ  r×  rÙ  rÚ  rÜ  rà  rä  r   r;   rà   rá   r	   rã  rð  rñ  r:   rú  r   r¿  r  r¦  r  r  r  r  r  r  r	  r  r•  r4   r/   r  r  r  )r~   rA   rU   r·  r  rÄ  r   Zretval_initr  r/   r#  rÇ   r&   r&   r'   rÃ   
  sb    













z,DefNodeWrapper.generate_function_definitionsr   c             C   sF  g }| j }|js| jr8dtj }|js.d| }| |¡ xF| jD ]<}|js@|jsV|j	rh| d|j
 ¡ q@| |j |j
¡¡ q@W | 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kr|jjrd}	d	}| j |j¡}
d
|	|
|f }| d| ¡ |r^| jjrZ| 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ksÔ| d|j&| '¡ f ¡ |jr | d¡ | d|j# ¡ | d¡ |s| jjr4| (d|j) ¡ |j*| jjdd	d | d| ¡ d S )NzPyObject *%szCYTHON_UNUSED zCYTHON_UNUSED PyObject *unusedÚ__ipow__zPyObject *%s, PyObject *%sz, r«   )rÀ  rÁ  Fzstatic %s%s(%s)z%s; /*proto*/T)rÅ  zstatic char %s[] = %s;z #if CYTHON_UPDATE_DESCRIPTOR_DOCzstruct wrapperbase %s;z#endifzstatic PyMethodDef %s = rÆ  )Z
allow_skipz%s {)+r  r§  rŠ  r	   r÷  r  rR   rU  r  rT  r  r„  rá   rQ  rÇ   r  Zmethod_flagsr   Zmethod_noargsr0  r  r:   r‹  Ú
args_cnameÚ
kwds_cnamer¡   r   r`  rO   r­  rÜ  r   r  r-   Zis_property_scoperœ  Z
is_unicodeZas_utf8_stringr›  Zas_c_string_literalrÝ  r®  Zput_pymethoddef)r~   rU   rÄ  rÅ  r¨  r  r(  r9  rÇ   Úmfrª  re  Zdocstrr&   r&   r'   rÜ  K  sr    










z'DefNodeWrapper.generate_function_headerc             C   s^   x8| j D ].}|jr|jr*| d|j ¡ q| |j¡ qW x|jD ]}|jrB| |¡ qBW d S )NzPyObject *%s = 0;)	rR   rU  r…  rO   r  râ  rÇ   r•  r4   )r~   rA   rU   r9  rÇ   r&   r&   r'   rà  –  s    z-DefNodeWrapper.generate_argument_declarationsc       	      C   s`  |  ¡ }|j}| d¡}| jdk}| jd k	p8| jd k	p8|}x"| jD ]}|jjsB|j 	|¡sBqBW |  
¡ s‚|rvt| jdƒ |  |¡ n$|  ¡ s–|  |¡ n|  | j||¡ ||_| |¡rF| |¡sÌ| |¡ | |¡ |r|  | j|¡ | jr| jjjr| | jj¡ n| | jj¡ | | jjj¡ | ¡  | d|  ¡  ¡ | |¡r\| |¡ d S )NZargument_unpacking_doner   z.This method cannot have * or keyword argumentsz
return %s;)Únew_error_labelr  rÖ  rr  r9  r:  rR   r/   r;   r¯  r±  r   r%   rj  r°  Úgenerate_stararg_copy_codeÚ'generate_tuple_and_keyword_parsing_codeÚ
label_usedr  r  Úgenerate_arg_decrefrÇ   rþ  Úput_var_xdecref_clearÚput_var_decref_clearr  rQ  r  r  rO   r  )	r~   rA   rU   Úold_error_labelÚour_error_labelÚ	end_labelZhas_kwonly_argsZhas_star_or_kw_argsr9  r&   r&   r'   rú  ¡  sB    





z-DefNodeWrapper.generate_argument_parsing_codec             C   s   |r|  |j¡ d S )N)r»  rÇ   )r~   r9  rU   r&   r&   r'   Úgenerate_arg_xdecrefÏ  s    z#DefNodeWrapper.generate_arg_xdecrefc             C   s   |r|  |j¡ d S )N)r¼  rÇ   )r~   r9  rU   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ÚRaiseArgTupleInvalidzFunctionArguments.cz)if (unlikely(PyTuple_GET_SIZE(%s) > 0)) {zK__Pyx_RaiseArgtupleInvalid("%s", 1, 0, 0, PyTuple_GET_SIZE(%s)); return %s;rÉ  zunlikely(%s)z%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 )N)rT   Z
allow_null)r†   Úrefr&   r&   r'   rÓ   ñ  s    z<DefNodeWrapper.generate_stararg_copy_code.<locals>.<genexpr>z	if (%s) {z3%s = PyDict_Copy(%s); if (unlikely(!%s)) return %s;z} else {z
%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Î  z
return %s;zPyTuple_SET_ITEM(%s, 0, %s);F)r¥  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);z%s = %s;)"r9  rÂ   rl  r   rÔ  rO   r	   r³  rÝ  r:   r  r:  rÇ   r]  r´  ÚboolrÕ   Zcf_referencesr  rª  rþ  rŠ  rQ  rz  Úput_xdecref_clearr   rõ  r÷  rN  r¦  r§  r
   Úc_py_ssize_t_typer­  )r~   rU   Zkwarg_checkr®  r&   r&   r'   r·  ×  s–    








z)DefNodeWrapper.generate_stararg_copy_codec          	      s˜  ˆ   d¡}g }g }g }xj|D ]b}|jr|jrV|js~|js~|jrJ| |¡ q~| |¡ q|jrh| |¡ q|js|js| |¡ qW || }	| 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r\d
p^d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¡ xft|	ƒD ]Z\}}|js$ˆ  |j¡}ˆ j t dd¡¡ ˆ  d| j|f ¡ ˆ  ˆ   | j!¡¡ P q$W nnˆ  d¡ |
|krÌx,t|ƒD ] \}}ˆ  d|tj|f ¡ q¤W n(ˆ  dtj ¡ | j
rîˆ  d¡ t"t|ƒƒd d d… }xd|D ]\\}}||
d krN||d d kr<ˆ  d¡ ˆ  d|d  ¡ ˆ  d|tj|f ¡ q
W |
dkrˆˆ  d¡ ˆ  d¡ ˆ  d¡ | j
rÖ|
rêx(t#|
d ddƒD ]}ˆ  d| ¡ q²W ˆ  |¡ nˆ  d¡ ˆ  |¡ ˆ  d¡ ˆ  d¡ x(t|ƒD ]\}}|  $|d| ˆ ¡ qW ˆ  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 )z&%s)Úintern_identifierr:   )r†   r9  )rU   r&   r'   rˆ   R  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) {z} else {ÚRaiseKeywordRequiredzFunctionArguments.cz&__Pyx_RaiseKeywordRequired("%s", %s); z&values[%d] = PyTuple_GET_ITEM(%s, %d);zswitch (PyTuple_GET_SIZE(%s)) {zdefault:r®   zCYTHON_FALLTHROUGH;z
case %2d: z	case  0: zbreak;z	case %2d:z	default: rÉ  z
values[%d]rÁ  zD__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, PyTuple_GET_SIZE(%s)); )'rÖ  rU  rÛ   r  rT  rV  r  rt  rs  rH   r9  rÃ  r:  Úgenerate_stararg_init_coderO   Útupler	   Úpykwdlist_cnamer¡   Ú#generate_argument_values_setup_coder´  Úgenerate_keyword_unpacking_coder³  r  r  rÇ  r:   rÂ   rl  r   rÔ  rÝ  r«  r%   r‹   ri  Úgenerate_arg_assignmentr¹  r  )r~   rR   Zsuccess_labelrU   Úargtuple_error_labelrr  Zrequired_kw_only_argsZoptional_kw_only_argsr9  Úkw_only_argsÚmin_positional_argsÚmax_positional_argsÚhas_fixed_positional_countÚhas_kw_only_argsÚall_argsÚcomparer(  Úpystring_cnameZreversed_argsr&   )rU   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 )Nz%s = %s;z	if (%s) {z} else {T)rÊ  rÉ  z2Cannot convert Python object argument to type '%s')r/   r;   rU  r
   Ztypecastr   rÇ   rO   r  Úfrom_py_functionrÛ   Úfrom_py_call_coder%   rK  rŠ  rý  r   )r~   r9  r   rU   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));zif (unlikely(!%s)) {z
return %s;rÉ  z} else {z	%s = %s; )r:  rÇ   rþ  rO   r  r  rª  r9  r	   r³  r¬  r   r  rÝ  rô  rõ  )r~   rÔ  rU   r&   r&   r'   rË  Ù  s4    




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 ¡ xFt|ƒD ]:\}}|j	rX|j
jrX| |¡}| d||j
 |¡f ¡ qXW d S )NzPyObject* values[%d] = {%s};rÆ  rl  z+%s *%s = __Pyx_CyFunction_Defaults(%s, %s);zvalues[%d] = %s;)rH   rO   r¡   rQ  r¬  r	   Zdynamic_args_cnamer÷  r  rÛ   r/   r;   rK  r  )r~   rR   rU   Zmax_argsr(  r9  rH  r&   r&   r'   rÎ  õ  s    

z2DefNodeWrapper.generate_argument_values_setup_codec             C   sš  |  d¡ |  dtj ¡ |  d¡ | jr4|  d¡ xJt|d ddƒD ]6}| d|d  ¡ |  d|tj|f ¡ |  d	¡ qFW |  d
¡ | js¤| d¡ | |¡ |  d¡ |  dtj ¡ | jsÎ|dkrìd}	xt	|ƒD ]\}}
|
j
sÜ|}	qÜW |	|k r|d }	|dkr|  d¡ x¼t	|d |	d … ƒD ]¢\}}
|dkrŽ||krŽ|dkrb|  d	¡ | jr€||kr€|  d¡ n|  d| ¡ | |
j¡}|
j
ræ|
jr®q0|  d¡ |  dtj|f ¡ |  d| ¡ |  d¡ nì|  d|tj|f ¡ ||k r||dkr&| d¡ | |¡ nT|  d¡ |j t dd¡¡ | d| j||||f ¡ |  | | j¡¡ |  d¡ nV|
jr0|  d¡ |j t dd¡¡ | d| j|f ¡ |  | | j¡¡ |  d¡ q0W |dkrì|  d¡ |rþ|  ||¡ |  d¡ |dkrd}n$| jr8|  d||f ¡ d}nd}|j t d d¡¡ |  d!tjtj| jrr| jjjptd|| 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) {zdefault:r   r®   z
case %2d: z&values[%d] = PyTuple_GET_ITEM(%s, %d);zCYTHON_FALLTHROUGH;zcase  0: break;z	default: rÉ  zkw_args = PyDict_Size(%s);r   z	case %2d: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 zelse {rÁ  zFunctionArguments.cz2__Pyx_RaiseArgtupleInvalid("%s", %d, %d, %d, %d); rÊ  z&__Pyx_RaiseKeywordRequired("%s", %s); zif (unlikely(kw_args > 0)) {rl  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)rO   r	   r³  r9  ri  rÝ  r  r´  rt  r  rÛ   rÇ  r:   rV  rÂ   rl  r   rÔ  r«  r%   Ú,generate_optional_kwonly_args_unpacking_coderÍ  r:  rÇ   r  )r~   rÓ  rÔ  rÕ  rÖ  r×  rÑ  rU   r(  Zlast_required_argr9  rÙ  Zpos_arg_countr&   r&   r'   rÏ    sª    









"











z.DefNodeWrapper.generate_keyword_unpacking_codec             C   sô   g }d}x6t |ƒD ]*\}}|jr|js(q|s0|}| |j¡ qW |rðt|ƒdkr˜| d| j rbdpdd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É  )r  rV  rÛ   r  r:   rH   rO   r:  r	   r´  rÍ  )r~   r×  rU   Zoptional_argsZfirst_optional_argr(  r9  r&   r&   r'   rÜ    s0    



z;DefNodeWrapper.generate_optional_kwonly_args_unpacking_codec             C   s&   x | j D ]}|jr|  ||¡ qW d S )N)rR   r…  Úgenerate_arg_conversion)r~   rU   r9  r&   r&   r'   rj     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 )Nz	if (%s) {zassert(%s); {rÉ  z%s = %s;z+Cannot convert 1 argument from '%s' to '%s')r„  r/   r;   rÛ   rO   r  Ú%generate_arg_conversion_from_pyobjectÚ#generate_arg_conversion_to_pyobjectr#  rÇ   r  r   r%   )r~   r9  rU   Úold_typeÚnew_typer&   r&   r'   rÝ  ¨  s    
z&DefNodeWrapper.generate_arg_conversionc             C   s@   |j }|jr,| | |j|jj|j|¡¡ nt|jd| ƒ d S )Nz2Cannot convert Python object argument to type '%s')	r/   rÚ  rO   rÛ  r  rÇ   r  r%   r   )r~   r9  rU   rá  r&   r&   r'   rÞ  »  s    
z4DefNodeWrapper.generate_arg_conversion_from_pyobjectc          
   C   s\   |j }|j}|rH| d|jj||j| |jj|j¡f ¡ | |j¡ nt	|jd| ƒ d S )Nz%s = %s(%s); %sz5Cannot convert argument of type '%s' to Python object)
r„  Zto_py_functionrO   rÇ   r  r  r©  r%   Zput_var_gotrefr   )r~   r9  rU   rà  rZ   r&   r&   r'   rß  È  s    z2DefNodeWrapper.generate_arg_conversion_to_pyobjectc             C   sR   xL| j D ]B}|jr |  ||¡ q|js|jjs>|jjs>|jjr|  ||¡ qW d S )N)	rR   rk  r)  r&  r/   r;   rß   rŠ  r+  )r~   rU   r9  r&   r&   r'   r   Õ  s    z+DefNodeWrapper.generate_argument_type_testsc             C   s   | j jS )N)r  r  )r~   r&   r&   r'   r  á  s    zDefNodeWrapper.error_value)r   )rK   rk   rl   ZdefnoderQ  r€   r   r   r°  r±  r¿  rÃ   rÜ  rà  rú  rÀ  rº  r·  r¸  rÐ  rË  rÎ  rÏ  rÜ  rj  rÝ  rÞ  rß  r   r  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|Ž d S )NT)rË   r¹   r“   )rÊ   rd   râ  r€   )r~   r%   rs   )rJ   r&   r'   r€   ô  s    zGeneratorDefNode.__init__c                s*   t t| ƒ |¡ | j| j_| j |¡ d S )N)rd   râ  r   r¼  rä  )r~   rA   )rJ   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); %srm  Úgenzgen->classobjz&%s = __Pyx_CyFunction_GetClassObj(%s);zreturn (PyObject *) gen;rÉ  )rä  rÇ   r`  rÇ  r:   ÚqualnameÚmodule_namerO   Úgen_type_namerì  rí  r	   rÑ  r©  r%   r  r   r«  r÷  rõ  rN  r  )r~   rA   rU   Z
body_cnamer:   ræ  rç  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 )NzCoroutine.cT)Úproto)	rl  r   rÔ  rè  rä  rÜ  rd   râ  rÃ   )r~   rA   rU   )rJ   r&   r'   rÃ     s    z.GeneratorDefNode.generate_function_definitions)rK   rk   rl   rê  Úis_coroutineÚis_iterable_coroutineÚis_asyncgenrè  r»  rL  r‰   r€   r   r¿  rÃ   rm   r&   r&   )rJ   r'   râ  å  s   râ  c               @   s   e Zd ZdZdZdS )ÚAsyncDefNodeÚ	CoroutineTN)rK   rk   rl   rè  rê  r&   r&   r&   r'   rí    s   rí  c               @   s   e Zd ZdZdZdS )ÚIterableAsyncDefNodeZIterableCoroutineTN)rK   rk   rl   rè  rë  r&   r&   r&   r'   rï  "  s   rï  c               @   s   e Zd ZdZdZdS )ÚAsyncGenNodeZAsyncGenTN)rK   rk   rl   rè  rì  r&   r&   r&   r'   rð  '  s   rð  c                   sP   e Zd ZdZdZdZdZd‡ fdd„	Zdd„ Zdd	„ Z	dd
d„Z
dd„ Z‡  ZS )ÚGeneratorBodyDefNodeTFNc          
      s$   t t| ƒj||||d g d d d d S )N)r%   r“   r:   Úis_async_gen_bodyr-   rR   r9  r:  )rd   rñ  r€   )r~   r%   r:   r“   rò  )rJ   r&   r'   r€   5  s    
zGeneratorBodyDefNode.__init__c             C   s\   |  |j¡}|  d¡}tj| | }|jd t| j|dd}||_t| j	ƒ|_
d|_|| _d S )NÚ	generatorr[  )r  ræ   T)r˜  r™  r	   Zgenbody_prefixr3  r   r%   r`  r   r:   r  r7  rÇ   )r~   rA   r  r:   r  rÇ   r&   r&   r'   Údeclare_generator_body:  s    

z+GeneratorBodyDefNode.declare_generator_bodyc             C   s   |   |¡ |  |¡ d S )N)r{  rô  )r~   rA   r&   r&   r'   r   H  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_cnamerO   )r~   rU   ré  re  r&   r&   r'   rÜ  L  s    
z-GeneratorBodyDefNode.generate_function_headerc          	   C   sØ  | j }| j ||¡ | |¡ | ¡ |_| | j¡ |  ||¡ | 	d¡ |  
|¡ | ¡ }| 	dtj ¡ | ¡ }| ¡  | | jjpŽ| jj¡ |jjd }|jjd }|s²|râ| ¡  d|j_| jrÔ| j |¡nd }| |¡ |j |jjj¡ | ¡ }	| d¡}
| |
¡ |  |
¡ | 	d| !tj"| j¡ ¡ | j#r¾| j$d k	r¾| j$}|t%j&kr`d}n0|t%j'krrd	}n|t%j(kr„d
}nt)d| ƒ‚| 	dtj|| !tj| j¡f ¡ | *tj¡ |  +||¡ |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¡rT| jj1s¶| 8|j9¡ |  |j7¡ | j#rä| j$d k	rä| :tjt;¡ t<j=| >¡ j?j@kr |j 3t4 5dd¡¡ | 	dtA| j2ƒ ¡ x$|j B¡ D ]\}}| C||¡ q,W | D| jj¡ |  |j9¡ | j#rv| 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"|
 ¡ x&|jKD ]\}}|	 	d#||f ¡ qfW |	 	d$¡ |sœ|r°|	jFd%|jjG d |	 H¡  |	 	d&¡ |	 	d ¡ | L¡  d S )'Nr«   zPyObject *%s = NULL;rÂ  rÃ  TZ	first_runz%szPyList_New(0)zPySet_New(NULL)zPyDict_New()z)invalid type of inlined comprehension: %sz%s = %s; %sz%s = %s;z%s->closurezCYTHON_MAYBE_UNUSED_VAR(%s);Fz/* function exit code */ÚStopAsyncIterationzCoroutine.cz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);z#endifz%s->resume_label = -1;z%__Pyx_Coroutine_clear((PyObject*)%s);)r  z
return %s;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È   rO   rÜ  rä  r	   rã  rð  rñ  rÇ   r:   r  rÂ   rÀ   rë  r¦  rù  rì  rí  rî  Zinit_closure_tempsrÞ  r/   r0  Z	use_labelr  r©  rö  Ú
is_inlinedÚinlined_comprehension_typer   Z	list_typeÚset_typeÚ	dict_typer   rª  r¿  r•  rá   rÑ  rJ  rõ  r¹   rò  rl  r   rÔ  r¹  r  r  r  rÄ  r   r   Úgenerator_stoprÅ   ÚcontextZfuture_directivesrÃ  r  r	  r  r  r  rØ  r  r  rø  Zyield_labelsr  )r~   rA   rU   r·  Zclosure_init_coder   rÂ  rÃ  rì  Zresume_codeZfirst_run_labelÚtarget_typeZ	comp_initr  r/   r(  Úlabelr&   r&   r'   rÃ   W  sÎ    



















z2GeneratorBodyDefNode.generate_function_definitions)NNNF)F)rK   rk   rl   r7  rø  rò  rù  r€   rô  r   rÜ  rÃ   rm   r&   r&   )rJ   r'   rñ  ,  s   
rñ  c               @   s&   e Zd ZdgZdZdd„ Zdd„ ZdS )rP  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†   r9  )rô   r~   r&   r'   rˆ   ü  s   z9OverrideCheckNode.analyse_expressions.<locals>.<listcomp>)rT  rR   )Úexpr)r7   )rË   )ræ  rR   rÛ  r‰  r«   rô   ÚRawCNameExprNoder%   r   Ú	func_noderU  r   rà   Úis_returncoderÊ   ÚExprStatNoderV  r“   rp   )r~   rA   Z	first_argZ	call_noder&   )rô   r~   r'   rp   ò  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 )Nz((PyObject *)%s)r   z /* Check if called by wrapper */zif (unlikely(%s)) ;z#/* Check if overridden in Python */zelse {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PyDictVersioningz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);z#endifT)r¥  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_cnamerR   r  rO   r^  rÂ   rl  r   rÔ  Ztp_dict_version_tempZobj_dict_version_tempZtype_dict_guard_tempr¦  r§  r   r  Ú	set_cnamer©  r%   rª  r`  r“   rÄ   r¬  r
   r­  )r~   rU   Zinterned_attr_cnamer©  Zfunc_node_tempÚerrZis_builtin_function_or_methodZis_overriddenr&   r&   r'   rÄ     sh    











z)OverrideCheckNode.generate_execution_code)rK   rk   rl   r‰   r“   rp   rÄ   r&   r&   r&   r'   rP  ä  s   
rP  c               @   s   e Zd ZdS )ÚClassDefNodeN)rK   rk   rl   r&   r&   r&   r'   r  V  s   r  c            	   @   sp   e Zd Zddddddddd	g	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 )ÚPyClassDefNoder“   rb   Ú	metaclassÚmkwrg   Úclass_resultrQ  Ú
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æxVtt|jƒƒd d d… D ]:\}}|jjdkr | jd k	rÊt|jdƒ |j| _|j|= q W || _n| jd k	sôt‚n|	 |¡| _|s | js | js | jrª| jd krx|rB|jsB| j}nd }|sb| jjrb| jjsbn|	j|| d	| _d}nd}|	j|||
| d
| _|	j||| |
||d| _ n$|	j!|g d| _|	j"||| |
d| _ |	j#||d| _$|	 %| j¡| _&d S )Nr   )rô   )r7   FTr®   r
  z2keyword argument 'metaclass' passed multiple times)Úclass_def_node)r:   r-   r  )r:   r  r-   Zcalculate_metaclassÚallow_py2_metaclass)r6   )r:   r  r-   )r:   )'rÐ   r€   r:   r-   r“   r  rg   r«   rô   r   r  r.   r%   Z
StringNodeÚis_py3_style_classr5   r6   r‹   r  r¦   r7   r
  r   r  ÚAssertionErrorÚ	ProxyNodeZis_sequence_constructorrR   ZPyClassMetaclassNodeZPyClassNamespaceNoderb   ZPy3ClassNodeÚclassobjÚDictNodeZ	ClassNoder  rQ  ZClassCellInjectorNoder  )r~   r%   r:   rg   r-   r“   r  rs  Zforce_py3_semanticsrô   Zdoc_noder  r(  r   ZmkdictZneeds_metaclass_calculationr&   r&   r'   r€   r  sd    "


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[  )rR   F)ræ   rç  Ú
class_namerg   r  r“   rç   r-   )r  r   r  r%   r«   rô   ÚCClassDefNoder:   rg   rï   r  r“   r-   )r~   rô   r&   r&   r'   Ú	as_cclass¸  s    zPyClassDefNode.as_cclassc             C   s4   |}x|j s|jr|j}qW t| j|d }| _|S )N)r:   rˆ  )rº  r  rˆ  r   r:   r0  )r~   rA   r½  r  r&   r&   r'   Úcreate_scopeË  s
    
zPyClassDefNode.create_scopec             C   s¼   | j }| jrLddlm} x,| jd d d… D ]}||j|j|gd}q*W d | _|| _| jrd| j |¡ | j	rv| j	 |¡ | j |¡ | j
 |¡ |  |¡}|j|_| j
jj|_| j |¡ d S )Nr   )rU  r®   )rT  rR   )r  r  rô   rU  r%   rI  r  rg   r   r  rQ  Úanalyse_target_declarationr  rÀ   rÇ   r  Úclass_obj_cnamer“   )r~   rA   r  rU  rI  r  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 )N)rg   rp   r  r
  rb   r  r0  r“   rQ  Úanalyse_target_expressionr  r  )r~   rA   r  r&   r&   r'   rp   è  s    z"PyClassDefNode.analyse_expressionsc             C   s"   |   | j|¡ | j | j|¡ d S )N)rÉ   r0  r“   rÃ   )r~   rA   rU   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 k	rŠ|jsŠd }|d k	rœ| |¡ | j |¡ | j |¡ |d k	rÎ| || j 
¡ ¡ |d k	rê| |¡ | |¡ | j 
¡  |_|_| j | j|¡ | j	 |¡ | j	 |¡ | jrD| j |¡ | j |¡ | jrd| j |¡ | j |¡ | jr„| j |¡ | j |¡ |j ¡  d S )N)rÎ   r%   Zpyclass_stackr  r0  rg   rI  r  r
  rb   r   Únamespace_cnamer  r  Z	is_activer“   rÄ   r  Zgenerate_injection_codeÚgenerate_disposal_coderP  r  rQ  rS  Úpop)r~   rU   r  r  r&   r&   r'   rÄ   û  sL    


z&PyClassDefNode.generate_execution_code)NNF)rK   rk   rl   r‰   r  r  r  r
  r  r€   r  r  r   rp   rÃ   rÄ   r&   r&   r&   r'   r	  Z  s   
 
E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   )ru  F)Zneed_complete)rD  r«   ru  Úbuffer_defaults_noderv  Úbuffer_defaults_posr  )r~   rA   ru  r&   r&   r'   rw  H  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 )Nr
  Ú.r   )r:   r%   r?  Úimplementingrç  rC   Úobjstruct_cnameÚtypeobj_cnameræ   r1  Ú
check_sizer„  rw  Úshadow)rç  ræ   Úsplitr`  r%   Údeclare_c_classr  Úobjstruct_nameÚtypeobj_namer1  r&  r„  rw  r'  rÇ   )r~   rA   r^  Ú
home_scoper&   r&   r'   r”  T  s*    zCClassDefNode.declarec                s  ˆ j rˆjstˆjdƒ ˆjr0tˆjdˆj ƒ d ˆ_ˆjr”d ˆ_x ˆ j	D ]}|j
ˆjkrJ|ˆ_qJW ˆjd kr”tˆjd ˆ jƒˆ_dˆj_ˆ  ˆj¡ ˆjjrâˆjjd }| ˆ ¡}|tjtjtjfkrØˆ  | ¡ ¡j}|d krôt|jdˆj ƒ nÀ|tjkrd }n®|js0|jr|js0t|jd| ƒ n„| ¡ sTt|jd|j
ˆjf ƒ n`|jr†|jjr†|j r†t|jd|ˆjf ƒ n.|jr®|j
d	kr®t|jd
|j
 ƒ n|ˆ_ˆ j !dd¡dkrâ|tjkrât"ˆjddƒ ˆj#d k	}|r ˆjr ˆjjs ˆjj$ %‡ ‡fdd„¡ d S ˆjrZˆj&dkrZˆj 'd¡}ˆ  (|ˆj¡}|s^d S nˆ }ˆj&dkr¬ˆjdkr¬ˆjt)j*kr¬ˆ j+d d… dkr¬t"ˆjdˆj dƒ |j,ˆjˆj|oÂˆj-|oÎˆj- ˆjˆjˆjˆj.ˆj/ˆj&ˆj0ˆj1ˆ 2ˆ ¡ˆj3dˆ_4ˆj3rˆj4| ˆj¡_5|ˆ k	rDˆj&dkrDˆ  6ˆjˆj4ˆj¡ ˆj4jj ˆ_}	|	d k	rfˆ 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ƒ x2ˆjjdd … D ]}| ˆ ¡r@t|jdƒ q@W 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¡ xˆj4jj$D ]}|ƒ  qþW 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 )N)r   r&   )rA   r~   r&   r'   Ú<lambda>¤  ó    z4CClassDefNode.analyse_declarations.<locals>.<lambda>r
  r"  Ú__builtin__é   zcpython.z %s already a builtin Cython type)r:   r%   r?  r#  rç  rC   r$  r%  r&  ræ   r1  r„  rw  r'  r|   Z__dict__getterz'Only declare first base in declaration.z+Only one extension type base class allowed.)rô   )r7   )r6   )rR   )MrÔ   r*  r   r%   r  r  rC   rç  ÚmoduleZcimported_modulesr:   r   rý  Zhas_extern_classÚadd_imported_modulerg   rR   r8   r
   r=   r<   r>   r_  Zsign_and_namer/   r   r†  r'  r$  rû   r0  rÀ   r—  r4  r   r“   Zdefered_declarationsr  ræ   r(  r`  r   Zbuiltin_typesr  r)  rç   r+  r&  r1  r„  rw  r'  rÇ   rM  Úadd_imported_entryr-   r   r  r.   r   ro  Zis_variableZdefinedZimplementedZmangle_internalZgetter_cnameÚdeclare_propertyrH   Ú
early_initr«   rô   rï   ZIdentifierStringNoder  Útype_init_argsZis_externalZallocate_vtable_names)r~   rA   r3  rê   rC   Zbase_class_scopeZhas_bodyr^  r,  r0  Z
dict_entryZ
other_baserô   Zthunkr&   )rA   r~   r'   r   m  sÚ    




 




z"CClassDefNode.analyse_declarationsc             C   s4   | j r| jjj}| j  |¡| _ | jr0| j |¡ | S )N)r“   rÇ   r/   r0  rp   r8  )r~   rA   r0  r&   r&   r'   rp   ö  s    
z!CClassDefNode.analyse_expressionsc             C   s(   | j r$|  | j|¡ | j  | j|¡ d S )N)r“   rÉ   r0  rÃ   )r~   rA   rU   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Ç   r/   r7  r8  rI  r   r¦  r§  r
   r   rO   r©  rª  r«  r­  rõ  rN  r%  r¬  r  rP  Úgenerate_type_ready_code)r~   rU   rg   Z
first_baseZ
trial_typer&   r&   r'   rÄ     s8    



z%CClassDefNode.generate_execution_codec          
   C   sÈ  | j }|j}|j}|sd S | jdkr¦xtjD ]}| ||¡ q.W |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¡ x| j jjD ] }|jdk}|jr6tjr6|jr6|s6tj |j¡}|r€| ¡ nd }|r”| |¡ | d¡ | d¡ | d||j| d| j¡f ¡ | d¡ | d|j ¡ | d|j|jf ¡ | d|j ¡ | d¡ | d¡ | d¡ |r6| d¡ q6W |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 }|r\|j t%krPd%| }|j&r,|j'}n
d&|j' }| d'||||j(f ¡ nt)|jd(ƒ |j#sr| $d)¡r¦nd r¦|j t	 
d*d¡¡ | d+|| | j¡f ¡ |jrÄ| d,|j*|jf ¡ d S )-Nr
  ZPyType_ReadyzExtensionTypes.cZ__Pyx_PyType_Readyzif (%s(&%s) < 0) %sz#if PY_VERSION_HEX < 0x030800B1z%s.tp_print = 0;z#endifZtp_getattroZtp_dictoffsetrl  Z#__Pyx_PyObject_GenericGetAttrNoDictZPyObject_GenericGetAttrNoDictZ__Pyx_PyObject_GenericGetAttrZPyObject_GenericGetAttrzObjectHandling.cz„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Á  z #if CYTHON_UPDATE_DESCRIPTOR_DOCrÎ  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	SetVTablez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;)+r/   r%  r0  ræ   r   Z
slot_tableZgenerate_dynamic_init_coderÂ   rl  r   rÔ  rO   r«  r%   Zget_slot_code_by_namer—  Zpyfunc_entriesr:   r  r   r  rœ  r3  r4  r5  r©  r›  Zvtable_cnameZvtabptr_cnameZis_internalrÀ   r	   r  rÇ  r  Zis_closure_class_scopero  r   r1  r$  r  r   ró  )rÇ   rU   Zheap_type_basesr/   r%  r0  r6  Z	readyfuncZgetattr_slot_funcZdictoffset_slot_funcZpy_cfuncZutility_funcrZ   rß   r  Zweakref_entryZtp_weaklistoffsetZ	objstructr&   r&   r'   r9  &  sÚ    













z&CClassDefNode.generate_type_ready_codec             C   s(   | j r| j  |¡ | jr$| j |¡ d S )N)r8  r”   r“   )r~   rU   r&   r&   r'   r”   ¯  s    zCClassDefNode.annotate)F)rK   rk   rl   r‰   r   r!  r1  r„  r*  r+  r&  r  r'  rw  r”  r   rp   rÃ   rÄ   rÏ   r9  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 )N)	r6  r:   r-   r%   rÇ   rÀ   r0  r“   r   )r~   rA   r&   r&   r'   r   À  s    z!PropertyNode.analyse_declarationsc             C   s   | j  |¡| _ | S )N)r“   rp   )r~   rA   r&   r&   r'   rp   Å  s    z PropertyNode.analyse_expressionsc             C   s   | j  ||¡ d S )N)r“   rÃ   )r~   rA   rU   r&   r&   r'   rÃ   É  s    z*PropertyNode.generate_function_definitionsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rÄ   Ì  s    z$PropertyNode.generate_execution_codec             C   s   | j  |¡ d S )N)r“   r”   )r~   rU   r&   r&   r'   r”   Ï  s    zPropertyNode.annotateN)	rK   rk   rl   r‰   r   rp   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"   x| j D ]}| || j¡ qW d S )N)ÚnamesZdeclare_globalr%   )r~   rA   r:   r&   r&   r'   r   Ú  s    zGlobalNode.analyse_declarationsc             C   s   | S )Nr&   )r~   rA   r&   r&   r'   rp   Þ  s    zGlobalNode.analyse_expressionsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rÄ   á  s    z"GlobalNode.generate_execution_codeN)rK   rk   rl   r‰   r   rp   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 )ÚNonlocalNodec             C   s"   x| j D ]}| || j¡ qW d S )N)r>  Zdeclare_nonlocalr%   )r~   rA   r:   r&   r&   r'   r   ì  s    z!NonlocalNode.analyse_declarationsc             C   s   | S )Nr&   )r~   rA   r&   r&   r'   rp   ð  s    z NonlocalNode.analyse_expressionsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rÄ   ó  s    z$NonlocalNode.generate_execution_codeN)rK   rk   rl   r‰   r   rp   rÄ   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 )r  r   c       
      C   sà   ddl m} | j}t||jƒr¢|j ¡ }|dkrÜ| ¡ \}}t|ƒrPt	|j
dƒ xH|jD ]>\}}| |¡}	|	d kr€t	|j
dƒ qX|j|j|	|j
dd qXW t| _n:t|dd ƒd k	rÜ|jrÊ| |¡ t| _n|jsÖ|jrÜt| _d S )	Nr   )rô   r”  z!Variable names must be specified.zUnknown typeT)r†  r@   )r«   rô   r   rI   ZGeneralCallNoderT  Úas_cython_attributeÚexplicit_args_kwdsrH   r   r%   r6   r8   r3  r7   ÚPassStatNoderJ   rŠ   r9   Zdeclare_from_annotationÚis_attributeÚis_subscript)
r~   rA   rô   r   rZ   rR   rS   Úvarr*  r/   r&   r&   r'   r   þ  s(    


z!ExprStatNode.analyse_declarationsc             C   s"   d| j _| j  |¡| _ d| j _| S )NF)r   Úresult_is_usedrp   )r~   rA   r&   r&   r'   rp     s    z ExprStatNode.analyse_expressionsc             C   s   | j jjr| j jr|  ¡  d S )N)r   r/   r;   Úis_tempr‚   )r~   rA   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%   r   rF  rI  rG  r   r/   rà   rO   r  rP  )r~   rU   r   r&   r&   r'   rÄ   $  s    

z$ExprStatNode.generate_execution_codec             C   s   | j  ||¡ d S )N)r   rÃ   )r~   rA   rU   r&   r&   r'   rÃ   0  s    z*ExprStatNode.generate_function_definitionsc             C   s   | j  |¡ d S )N)r   r”   )r~   rU   r&   r&   r'   r”   3  s    zExprStatNode.annotateN)rK   rk   rl   r‰   r   rp   r½   r   rÄ   rÃ   r”   r&   r&   r&   r'   r  ÷  s   r  c               @   s   e Zd Zdd„ Zdd„ ZdS )ÚAssignmentNodec             C   sB   |   |¡}t|tƒr>t|tƒs>|jjjr>|j ¡ r>t| j	dƒ |S )Nz9Storing unsafe C derivative of temporary Python reference)
ro   rI   rH  ÚParallelAssignmentNodeÚrhsr/   rÝ   Zis_ephemeralr   r%   )r~   rA   rT   r&   r&   r'   rp   @  s
    
z"AssignmentNode.analyse_expressionsc             C   s$   |  | j¡ |  |¡ |  |¡ d S )N)rÎ   r%   Úgenerate_rhs_evaluation_coderS  )r~   rU   r&   r&   r'   rÄ   K  s    
z&AssignmentNode.generate_execution_codeN)rK   rk   rl   rp   rÄ   r&   r&   r&   r'   rH  7  s   	rH  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 )ÚSingleAssignmentNoder!  rJ  Fc             C   s  ddl m} t| j|jƒr| jj ¡ }|r| j ¡ \}}|dkr°t|ƒdkrft	|d j
dƒ d S |d k	r¢| d ¡}|dksˆd|kr˜t	|j
dƒ d S |d }nd	}|d
  |¡}|d krÐt	|d
 j
dƒ d S | j}	|dkrvt|	|jƒrü|	j|	j
fg}
n0t|	|jƒrdd„ |	jD ƒ}
nt	|	j
dƒ d S x&|
D ]\}}|j|||d|d q2W t|ƒdkrn|d | _nd| _n6d| _t|	|jƒs–t	|	j
dƒ |j|	j|| j
d	d nR|dkr¼d| _t|ƒd
ksØ|d krêt	| jj
dƒ d S g }xJ|jD ]@\}}| |¡}|d kr t	|j
dƒ n| |j||j
f¡ qöW t|ƒt|jƒk rRd S t| j|jƒspt	| jj
dƒ | jj}t|ƒ}| |||d| jj
¡ xj|D ]\}}}| |||¡ qœW 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.rM  ræ   zInvalid keyword argument.r[  r   zUnknown typer”  c             S   s   g | ]}|j |jf‘qS r&   )r:   r%   )r†   rE  r&   r&   r'   rˆ     s    z=SingleAssignmentNode.analyse_declarations.<locals>.<listcomp>zInvalid declarationT)r†  ræ   zInvalid declaration.)ræ   )r.  Úunionz.Struct or union members must be given by name.FZ
fused_typez*fused_type does not take keyword arguments)r:   r`   )r«   rô   rI   rJ  ZCallNoderT  r@  rA  rH   r   r%   Úcompile_time_valuer8   r!  r  r:   rï   rR   r3  Údeclaration_onlyr€  r6   r  r7   r   r5  r  r   r  )r~   rA   rô   Ú	func_namerR   rS   Zkwdictræ   r/   r!  ÚvarsrE  r%   ÚmembersÚmemberr*  r:   r0  Z	fusednoder&   r&   r'   r   b  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 k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ê   rW   Ústopú=Tr  ZCppExceptionConversionzCppSupport.cpp) r«   rô   rJ  ro   Ú
unroll_rhsr!  rq   Úgil_assignment_checkÚ
unroll_lhsrI   ZMemoryViewIndexNodeZanalyse_broadcast_operationZ$analyse_as_memview_scalar_assignmentr/   rÞ   ÚSliceIndexNoder%   rñ   Zlookup_operator_for_typesÚis_overloaded_assignmentr  r   rl  r   rÔ  r"  rC  r9   r¸   r;   Úcoerce_to_tempÚcoerce_to_simple)r~   rA   Úuse_temprô   Zunrolled_assignmentÚoprJ  r&   r&   r'   ro   ¶  sH    







z"SingleAssignmentNode.analyse_typesc          	   C   s6  ddl m}m} |}d  } } }	}
|jjr8|jj}nj|jjsJ|jjržx&t||j	ƒrp|j
sp|jsp|j }}qLW t||j	ƒrt|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„ }y"||d ƒ||dƒ ||	dƒ }W n" tk
rp   t| jdƒ d S X n(|jjr˜|jj}t|tƒsœd S nd S nd S ||krÄt| jd	||f ƒ d S g }| |¡}|g}|rú|jsú| |¡}| |¡ |r|js| |¡}| |¡ |	r>|	js>| |	¡}	| |	¡ xìt|ƒD ]à}|j| jt|ƒ|tjd
}|	d k	r²|	 ¡ rž|j|	j }|j| jt|ƒ|d}n|j| jd|	|d}|d k	r| ¡ rô| ¡ rô|j|j }|j| jt|ƒ|d}n|j| jd||d}| |j| j||  |¡d¡ qHW |
||fS )Nr   )rô   Ú	UtilNodes)r7   r‡  z*C array iteration requires known end indexc             S   s&   | d kr|S |   ¡ r| jS tdƒ‚d S )NzNot a constant.)Úhas_constant_resultr‡  rú   )rT   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)r7   r‡  r/   r  )ÚoperatorZoperand1Zoperand2r  )rê   rõ   )!r«   rô   r`  r/   Ú	is_ctuplerþ   rÝ   rÞ   rI   rZ  rW   rU  rê   r"  r
   rÅ  ZIntNoder%   r-  r   Zconstant_value_not_setr   rú   Z
LetRefNoder¸   r  ri  ra  r‡  ZMulNodeZAddNodeZ	IndexNodero   )r~   rT   Ztarget_sizerA   rô   r`  rê   Z
start_nodeZ	stop_nodeZ	step_nodeÚ
check_nodeZ
slice_sizerb  rc   Úrefsrý   Zix_nodeZ
step_valueZindex_valuer&   r&   r'   Úunrollæ  sŠ    "











$zSingleAssignmentNode.unrollc          	   C   s”   ddl m} g }x0t||ƒD ]"\}}	| t| j||	| jd¡ qW t| j|d |¡}
|rlt	| j||
gd}
x"|d d d… D ]}| 
||
¡}
q|W |
S )Nr   )r`  )r!  rJ  Úfirst)r%   rË   r®   )r«   r`  rB  r  rL  r%   rh  rI  rp   rÊ   ZLetNode)r~   rf  re  Úlhs_listZrhs_listrA   r`  Úassignmentsr!  rJ  rT   rÂ  r&   r&   r'   Úunroll_assignmentsD  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 )N)Z
is_starred)r†   r9  r&   r&   r'   rÓ   T  s    z2SingleAssignmentNode.unroll_rhs.<locals>.<genexpr>)r«   rô   rI   r!  rï   ÚanyrR   rg  rJ  rH   rk  )r~   rA   rô   Úunrolledre  rf  rJ  r&   r&   r'   rW  P  s    
zSingleAssignmentNode.unroll_rhsc             C   sl   | j jjrd S ddlm} t| j|jƒs,d S |  | j t	| jj
ƒ|¡}|sLd S |\}}}|  |||| jj
|¡S )Nr   )rô   )r!  r/   rd  r«   rô   rI   rJ  rï   rg  rH   rR   rk  )r~   rA   rô   rm  re  rf  r!  r&   r&   r'   rY  ]  s    

zSingleAssignmentNode.unroll_lhsc             C   s   | j  |¡ d S )N)rJ  rI  )r~   rU   r&   r&   r'   rK  k  s    z1SingleAssignmentNode.generate_rhs_evaluation_codec             C   s:   | j r&| jj| j|| j | j| jd n| j | j|¡ d S )N)rR  r  r   )r[  r!  rS  rJ  r  r   )r~   rU   rR  r&   r&   r'   rS  n  s    z-SingleAssignmentNode.generate_assignment_codec             C   s   | j  ||¡ d S )N)rJ  rÃ   )r~   rA   rU   r&   r&   r'   rÃ   y  s    z2SingleAssignmentNode.generate_function_definitionsc             C   s   | j  |¡ | j |¡ d S )N)r!  r”   rJ  )r~   rU   r&   r&   r'   r”   |  s    zSingleAssignmentNode.annotateN)r   )F)rK   rk   rl   r‰   rh  r[  rP  r   ro   rg  rk  rW  rY  rK  rS  rÃ   r”   r&   r&   r&   r'   rL  Q  s   T
0^
rL  c               @   sX   e Zd ZddddgZdZdZdZdd„ Zdd	d
„Zdd„ Z	ddd„Z
dd„ Zdd„ ZdS )ÚCascadedAssignmentNoderi  rJ  Úcoerced_valuesÚcloned_valuesNc             C   s   x| j D ]}| |¡ qW d S )N)ri  r  )r~   rA   r!  r&   r&   r'   r   ”  s    z+CascadedAssignmentNode.analyse_declarationsr   c             C   sÒ  ddl m}m} tƒ }x@t| jƒD ]2\}}| |¡ }| j|< | |¡ | |j	¡ q"W | 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 | _x†| jD ]|}|j	jo4| d|| j
g¡}| j |¡ |j	|
kr|j	|j	kr|| j
ƒ}|sz| |j	|¡}| j |¡ ||
|j	< qW g | _x0| jD ]&}|
 |j	| j
¡}| j ||ƒ¡ q¤W | S )Nr   )Ú	CloneNoder  rV  )rô   rq  r  ry   r  ri  rq   rX  r¨   r/   rJ  ro   rH   ÚnextÚiterrñ   Zlookup_operatorr"  r  r9   r¸   rC  r;   r\  r]  rG  ro  Úassignment_overloadsr  rp  r4  )r~   rA   r^  rq  r  Z	lhs_typesr(  r!  rJ  r_  ro  Z
overloadedr&   r&   r'   ro   ˜  sF    


z$CascadedAssignmentNode.analyse_typesc             C   s   | j  |¡ d S )N)rJ  rI  )r~   rU   r&   r&   r'   rK  É  s    z3CascadedAssignmentNode.generate_rhs_evaluation_codeFc             C   s–   x| j D ]}| |¡ qW x:t| j| j| jƒD ]$\}}}| |¡ |j|||d q.W x"| j D ]}| |¡ | |¡ q^W | j	 |¡ | j	 |¡ d S )N)rR  )
ro  rI  rB  ri  rp  rt  rS  r  rP  rJ  )r~   rU   rR  rJ  r!  ÚoverloadÚ	rhs_valuer&   r&   r'   rS  Ì  s    

z/CascadedAssignmentNode.generate_assignment_codec             C   s   | j  ||¡ d S )N)rJ  rÃ   )r~   rA   rU   r&   r&   r'   rÃ   Û  s    z4CascadedAssignmentNode.generate_function_definitionsc             C   sZ   x| j D ]}| |¡ qW x.t| j| jƒD ]\}}| |¡ | |¡ q*W | j |¡ d S )N)ro  r”   rB  ri  rp  rJ  )r~   rU   rJ  r!  r&   r&   r'   r”   Þ  s    
zCascadedAssignmentNode.annotate)r   )F)rK   rk   rl   r‰   rp  ro  rt  r   ro   rK  rS  rÃ   r”   r&   r&   r&   r'   rn    s   
1
rn  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 )rI  rË   c             C   s   x| j D ]}| |¡ qW d S )N)rË   r   )r~   rA   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^  )ro   )r†   rÍ   )rA   r&   r'   rˆ   ü  s   z>ParallelAssignmentNode.analyse_expressions.<locals>.<listcomp>)rË   )r~   rA   r&   )rA   r'   rp   û  s    
z*ParallelAssignmentNode.analyse_expressionsc             C   sD   |  | j¡ x| jD ]}| |¡ qW x| jD ]}| |¡ q.W d S )N)rÎ   r%   rË   rK  rS  )r~   rU   rÍ   r&   r&   r'   rÄ     s
    z.ParallelAssignmentNode.generate_execution_codec             C   s    x| j D ]}| ||¡ qW d S )N)rË   rÃ   )r~   rA   rU   rÍ   r&   r&   r'   rÃ     s    z4ParallelAssignmentNode.generate_function_definitionsc             C   s   x| j D ]}| |¡ qW d S )N)rË   r”   )r~   rU   rÍ   r&   r&   r'   r”     s    zParallelAssignmentNode.annotateN)	rK   rk   rl   r‰   r   rp   rÄ   rÃ   r”   r&   r&   r&   r'   rI  ç  s   rI  c               @   s<   e Zd ZddgZdd„ Zdd„ Zdd„ Zd	d
„ Zdd„ ZdS )ÚInPlaceAssignmentNoder!  rJ  c             C   s   | j  |¡ d S )N)r!  r  )r~   rA   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krh| j  t
j|¡| _ | S )Nz+-)rJ  ro   r!  rq   Úis_memview_indexÚis_buffer_accessr"  r/   Ú	is_stringrc  r
   rÅ  )r~   rA   r&   r&   r'   ro   -  s    z#InPlaceAssignmentNode.analyse_typesc             C   s
  |  | j¡ | j| j }}| |¡ | |¡ | j}|dkrBd}n|dkrVt| jdƒ |jsb|j	r®|j
jrvt| jdƒ |dkrž|j
jrž|jjd sžt| jdƒ | |||¡ n0|jrÂt| jd	ƒ n| d
| ¡ || ¡ f ¡ | |¡ | |¡ | |¡ | |¡ d S )Nz//ú/z**zNo C inplace power operatorzAIn-place operators not allowed on object buffers in this release.)r{  ú%Z	cdivisionz;In-place non-c divide operators not allowed on int buffers.z4Inplace operators not supported on memoryview slicesz
%s %s= %s;)rÎ   r%   r!  rJ  rI  Z generate_subexpr_evaluation_coderc  r   ry  rx  r/   r;   rø   rÂ   rÀ   Zgenerate_buffer_setitem_codeZis_memview_slicerO   r   Zgenerate_subexpr_disposal_codeZfree_subexpr_tempsr  rP  )r~   rU   r!  rJ  Zc_opr&   r&   r'   rÄ   9  s,    




z-InPlaceAssignmentNode.generate_execution_codec             C   s   | j  |¡ | j |¡ d S )N)r!  r”   rJ  )r~   rU   r&   r&   r'   r”   T  s    zInPlaceAssignmentNode.annotatec             C   s$   ddl m} | | j| j| j| j¡S )Nr   )rô   )r«   rô   Z
binop_noder%   rc  r!  rJ  )r~   rô   r&   r&   r'   Úcreate_binop_nodeX  s    z'InPlaceAssignmentNode.create_binop_nodeN)	rK   rk   rl   r‰   r   ro   rÄ   r”   r}  r&   r&   r&   r'   rw    s   rw  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_tuplerM   c             C   sd   | j r| j  |¡}| |¡| _ | j |¡}| |¡| _| t¡ t| jjƒdkr`| jr`| t	¡ | S )Nr   )
rM   rp   Úcoerce_to_pyobjectr  rl  Úprinting_utility_coderH   rR   Úappend_newlineÚprinting_one_utility_code)r~   rA   rM   r  r&   r&   r'   rp   f  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 )Nrl  r   r   z"if (__Pyx_PrintOne(%s, %s) < 0) %sz#if (__Pyx_Print(%s, %s, %d) < 0) %s)rÎ   r%   rM   rI  Ú	py_resultrH   r  rR   r‚  rO   r«  r  rP  )r~   rU   Zstream_resultr9  r&   r&   r'   rÄ   t  s6    

z%PrintStatNode.generate_execution_codec             C   s&   | j r| j  ||¡ | j ||¡ d S )N)rM   rÃ   r  )r~   rA   rU   r&   r&   r'   rÃ   •  s    z+PrintStatNode.generate_function_definitionsc             C   s"   | j r| j  |¡ | j |¡ d S )N)rM   r”   r  )r~   rU   r&   r&   r'   r”   š  s    zPrintStatNode.annotateN)rK   rk   rl   r‰   rp   r{   r‚   r½   r   rÄ   rÃ   r”   r&   r&   r&   r'   r~  ]  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 )
ÚExecStatNoderR   c             C   sF   x4t | jƒD ]&\}}| |¡}| |¡}|| j|< qW | tj¡ | S )N)r  rR   rp   r€  rl  r   Zpyexec_utility_code)r~   rA   r(  r9  r&   r&   r'   rp   §  s    

z ExecStatNode.analyse_expressionszPython exec statementc             C   sÜ   |  | j¡ g }x&| jD ]}| |¡ | | ¡ ¡ qW t|ddgd dt|ƒ …  ƒ}|jj	t
jdd}| d|f|  ¡ x"| jD ]}| |¡ | |¡ q†W | | || j¡¡ | |¡ | |t¡ |j |¡ d S )Nrl  r$   T)r¥  z%s = __Pyx_PyExec3(%s, %s, %s);)rÎ   r%   rR   rI  r  r„  rÌ  rH   r¦  r§  r
   r   rO   r  rP  r©  rª  r¬  r­  )r~   rU   rR   r9  Ztemp_resultr&   r&   r'   rÄ   ²  s     
 

z$ExecStatNode.generate_execution_codec             C   s   x| j D ]}| |¡ qW d S )N)rR   r”   )r~   rU   r9  r&   r&   r'   r”   Ä  s    zExecStatNode.annotateN)rK   rk   rl   r‰   rp   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 )ÚDelStatNoderR   Fc             C   s   x| j D ]}| |¡ qW d S )N)rR   r  )r~   rA   r9  r&   r&   r'   r   Ñ  s    z DelStatNode.analyse_declarationsc             C   sº   x´t | jƒD ]¦\}}| |d ¡ }| j|< |jjs@|jr\|jjr\|jr²|jjr²t	|j
dƒ q|jjrz|jjjrz|  |¡ q|jjrt	|j
dƒ q|jr¦|jjtjkr¦qt	|j
dƒ qW | S )NzDeletion of global C variablezDeletion of non-heap C++ objectz&Deletion of non-Python, non-C++ object)r  rR   r  r/   r;   r9   rŠ  rÇ   Z
is_cglobalr   r%   rÝ   rC   rñ   r„   rD  rê   r   Úbytearray_type)r~   rA   r(  r9  r&   r&   r'   rp   Õ  s    zDelStatNode.analyse_expressionsc             C   s$   x| j D ]}|jjr|  ¡  qW d S )N)rR   r/   r;   r‚   )r~   rA   r9  r&   r&   r'   r½   æ  s    zDelStatNode.nogil_checkzDeleting Python objectc             C   s˜   |  | j¡ x†| jD ]|}|jjs<|jjs<|jrN|jjtj	krN|j
|| jd q|jjr|jjjr| |¡ | d| ¡  ¡ | |¡ | |¡ qW d S )N)Úignore_nonexistingz
delete %s;)rÎ   r%   rR   r/   r;   rŠ  rD  rê   r   r‡  Zgenerate_deletion_coderˆ  rÝ   rC   rñ   rI  rO   r   r  rP  )r~   rU   r9  r&   r&   r'   rÄ   í  s    

z#DelStatNode.generate_execution_codec             C   s   x| j D ]}| |¡ qW d S )N)rR   r”   )r~   rU   r9  r&   r&   r'   r”   ü  s    zDelStatNode.annotateN)rK   rk   rl   r‰   rˆ  r   rp   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 )rB  c             C   s   | S )Nr&   )r~   rA   r&   r&   r'   rp     s    z PassStatNode.analyse_expressionsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rÄ   	  s    z$PassStatNode.generate_execution_codeN)rK   rk   rl   r‰   rp   rÄ   r&   r&   r&   r'   rB    s   rB  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Ë   )rd   r‰  r€   r%   )r~   rË   )rJ   r&   r'   r€     s    zIndirectionNode.__init__)rK   rk   rl   rx   r€   rm   r&   r&   )rJ   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 )Nr&   )r~   rA   r&   r&   r'   rp     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   r  )r~   rU   r&   r&   r'   rÄ     s    z%BreakStatNode.generate_execution_codeN)rK   rk   rl   r‰   r¹   rp   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 )Nr&   )r~   rA   r&   r&   r'   rp   ,  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Î   r  )r~   rU   r&   r&   r'   rÄ   /  s
    z(ContinueStatNode.generate_execution_codeN)rK   rk   rl   r‰   r¹   rp   rÄ   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 )rV  r7   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)
r   r   r%   r7   Úin_async_genro   rà   r  r"  r;   )r~   rA   r   r&   r&   r'   rp   G  s"    z"ReturnStatNode.analyse_expressionsc             C   s   | j jr|  ¡  d S )N)r   r;   r‚   )r~   rA   r&   r&   r'   r½   \  s    zReturnStatNode.nogil_checkzReturning Python objectc             C   s¶  |  | j¡ | jsd S | j}| jjrB| tj| j¡ |rB|jrBd }|r
| 	|¡ | jj
rddlm} |jtj| j|j||| jd | |¡ nn| jrÎ|j t dd¡¡ | dtj| ¡ f ¡ | |¡ n0| |¡ | dtj| | j¡f ¡ | |¡ | |¡ nv| jjrf| jrT| jrB|j t dd¡¡ | d	¡ | d
tj ¡ n| tj| j¡ n| jjr€|  || jj ¡ x$|j! "¡ D ]\}}| #||¡ qŒW | $|j%¡ d S )Nr   )rh  )Z	lhs_cnameZlhs_typeZlhs_posrJ  rU   rÊ  ZReturnWithStopIterationzCoroutine.cz-%s = NULL; __Pyx_ReturnWithStopIteration(%s);z%s = %s;r÷  z/PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration); z
%s = NULL;)&rÎ   r%   r   r7   r;   r	  r	   rã  r·   rI  rŠ  r«   rh  Zput_acquire_memoryviewslicer¾   rO  Úin_generatorrÂ   rl  r   rÔ  rO   r„  r  rL  rM  rP  rŽ  rÝ  r  r  Ú
put_returnrH  r¦  Ztemps_holding_referencer¬  r  r  )r~   rU   r7   rh  r  r/   r&   r&   r'   rÄ   b  s\    







z&ReturnStatNode.generate_execution_codec             C   s(   | j r| d¡ | dtj|f ¡ d S )Nz%#pragma omp critical(__pyx_returning)z%s = %s;)Úin_parallelÚputln_openmprO   r	   rã  )r~   rU   r7   r&   r&   r'   r  œ  s    
zReturnStatNode.put_returnc             C   s   | j d k	r| j  ||¡ d S )N)r7   rÃ   )r~   rA   rU   r&   r&   r'   rÃ   ¡  s    
z,ReturnStatNode.generate_function_definitionsc             C   s   | j r| j  |¡ d S )N)r7   r”   )r~   rU   r&   r&   r'   r”   ¥  s    zReturnStatNode.annotateN)rK   rk   rl   r‰   r¹   r  rŽ  r‘  rp   r½   r   rÄ   r  rÃ   r”   r&   r&   r&   r'   rV  7  s   :rV  c               @   sF   e Zd Zddddg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 k	rÆ|jjsÌ|j}|jrò|jjrò|j| _| jdkròd | _ | S )Nr   )rô   ÚMemoryError)r”  ro   r€  r•  r–  r—  Úbuiltin_exc_namer«   rô   rI   rU  rR   r  rT  r9   rÇ   Ú
is_builtinr:   )r~   rA   r”  r•  r–  r—  Úexcrô   r&   r&   r'   rp   µ  s0    
z!RaiseStatNode.analyse_expressionszRaising exceptionc             C   sB  |  | 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 ¡ x8| j| j| j| jfD ] }|r| |¡ | |¡ qW | | | j¡¡ d S )Nr˜  zPyErr_NoMemory(); %srl  z__Pyx_Raise(%s, %s, %s, %s);)rÎ   r%   r™  rO   r«  r”  rI  r„  r9   rÂ   Zuse_entry_utility_coderÇ   r•  r–  r—  rl  Úraise_utility_coder  rP  )r~   rU   Z	type_codeZ
value_codeZtb_codeZ
cause_coder,  r&   r&   r'   rÄ   Ó  sF    



z%RaiseStatNode.generate_execution_codec             C   sd   | j d k	r| j  ||¡ | jd k	r0| j ||¡ | jd k	rH| j ||¡ | jd k	r`| j ||¡ d S )N)r”  rÃ   r•  r–  r—  )r~   rA   rU   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 )N)r”  r”   r•  r–  r—  )r~   rU   r&   r&   r'   r”     s    zRaiseStatNode.annotateN)rK   rk   rl   r‰   r¹   rp   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 )Nr&   )r~   rA   r&   r&   r'   rp     s    z#ReraiseStatNode.analyse_expressionszRaising exceptionc             C   sÆ   |  | j¡ |jj}|r˜|j t¡ | |d ¡ | |d ¡ | |d ¡ | 	dt
|ƒ ¡ x|D ]}| d| ¡ qfW | 	¡  | 	| | j¡¡ n*|j t dd¡¡ | 	d| | j¡ ¡ d S )	Nr   r   r"   z&__Pyx_ErrRestoreWithState(%s, %s, %s);z%s = 0; ZReRaiseExceptionzExceptions.cz__Pyx_ReraiseException(); %s)rÎ   r%   r¦  Úexc_varsrÂ   rl  r
  rN  r  rO   rÌ  rÝ  r«  r   rÔ  )r~   rU   rR  Úvarnamer&   r&   r'   rÄ     s    
z'ReraiseStatNode.generate_execution_codeN)rK   rk   rl   r‰   r¹   rp   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 )ÚAssertStatNoder$  r7   c             C   sz   | j  |¡| _ | jrv| j |¡}|jtjks4|jjsjddlm	} ||j
|gdd}|j|dd |¡| _n| |¡| _| S )Nr   )rï   T)rR   Zslow)Zskip_children)r$  Zanalyse_boolean_expressionr7   ro   r/   r   Z
tuple_typer'  rô   rï   r%   r€  )r~   rA   r7   rï   r&   r&   r'   rp   8  s    z"AssertStatNode.analyse_expressionszRaising exceptionc             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)) {zif (unlikely(!%s)) {z*PyErr_SetObject(PyExc_AssertionError, %s);z$PyErr_SetNone(PyExc_AssertionError);rÉ  z#endif)rO   rÎ   r%   r$  rI  r   r7   r„  r  rP  r«  )r~   rU   r&   r&   r'   rÄ   H  s.    

z&AssertStatNode.generate_execution_codec             C   s*   | j  ||¡ | jd k	r&| j ||¡ d S )N)r$  rÃ   r7   )r~   rA   rU   r&   r&   r'   rÃ   b  s    
z,AssertStatNode.generate_function_definitionsc             C   s"   | j  |¡ | jr| j |¡ d S )N)r$  r”   r7   )r~   rU   r&   r&   r'   r”   g  s    zAssertStatNode.annotateN)rK   rk   rl   r‰   rp   r{   r‚   r½   r   rÄ   rÃ   r”   r&   r&   r&   r'   r   0  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   s0   x| j D ]}| |¡ qW | jr,| j |¡ d S )N)r¢  r   r£  )r~   rA   Ú	if_clauser&   r&   r'   r   u  s    zIfStatNode.analyse_declarationsc                s.   ‡ fdd„| j D ƒ| _ | jr*| j ˆ ¡| _| S )Nc                s   g | ]}|  ˆ ¡‘qS r&   )rp   )r†   r¤  )rA   r&   r'   rˆ   |  s    z2IfStatNode.analyse_expressions.<locals>.<listcomp>)r¢  r£  rp   )r~   rA   r&   )rA   r'   rp   {  s    zIfStatNode.analyse_expressionsc             C   sÂ   |  | j¡ | ¡ }t| jƒ}| jr>| j| jd | jdd n|d8 }x8t| jƒD ]*\}}|  ||j¡ |j	||||kd qRW | jr´|  | jj¡ | 
d¡ | j 	|¡ | 
d¡ | |¡ d S )Nr®   T)Úinverser   )Úis_lastz
/*else*/ {rÉ  )rÎ   r%   rÖ  rH   r¢  r£  Ú_set_branch_hintr  r“   rÄ   rO   r  )r~   rU   r¿  Úlastr(  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rtttt	t
tf}x$|jd d… D ]}t||ƒs^d S q^W |r|dnd|_d S )Nr®   r   rÈ  r  )r¹   rI   rÊ   rË   r“  r  rH   r  rH  r†  r=  r?  Úbranch_hint)r~   ÚclauseZstatements_noder¥  Znon_branch_nodesrT   r&   r&   r'   r§  ”  s    
zIfStatNode._set_branch_hintc             C   s8   x| j D ]}| ||¡ qW | jd k	r4| j ||¡ d S )N)r¢  rÃ   r£  )r~   rA   rU   rª  r&   r&   r'   rÃ   £  s    
z(IfStatNode.generate_function_definitionsc             C   s0   x| j D ]}| |¡ qW | jr,| j |¡ d S )N)r¢  r”   r£  )r~   rU   r¤  r&   r&   r'   r”   ©  s    zIfStatNode.annotateN)F)
rK   rk   rl   r‰   r   rp   rÄ   r§  rÃ   r”   r&   r&   r&   r'   r¡  m  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 )N)r“   r   )r~   rA   r&   r&   r'   r   ¹  s    z!IfClauseNode.analyse_declarationsc             C   s    | j  |¡| _ | j |¡| _| S )N)r¬  Úanalyse_temp_boolean_expressionr“   rp   )r~   rA   r&   r&   r'   rp   ¼  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)z	if (%s) {F)rË  rÉ  )r¬  rI  rÎ   r%   r   r©  rO   r  rP  r“   rÄ   r¹   r  )r~   rU   r¿  r¦  r¬  r&   r&   r'   rÄ   Á  s    

z$IfClauseNode.generate_execution_codec             C   s    | j  ||¡ | j ||¡ d S )N)r¬  rÃ   r“   )r~   rA   rU   r&   r&   r'   rÃ   Ð  s    z*IfClauseNode.generate_function_definitionsc             C   s   | j  |¡ | j |¡ d S )N)r¬  r”   r“   )r~   rU   r&   r&   r'   r”   Ô  s    zIfClauseNode.annotate)
rK   rk   rl   r‰   r©  r   rp   rÄ   rÃ   r”   r&   r&   r&   r'   r«  °  s   r«  c               @   s4   e Zd ZddgZdd„ Zdd„ Zdd„ Zd	d
„ ZdS )ÚSwitchCaseNodeÚ
conditionsr“   c             C   s   x| j D ]}| |¡ qW d S )N)r¯  rI  )r~   rU   r$  r&   r&   r'   Ú"generate_condition_evaluation_codeá  s    z1SwitchCaseNode.generate_condition_evaluation_codec             C   sŽ   t | jƒ}|jjd }xLt| jdƒD ]<\}}| d| ¡  ¡ | |j¡ |r$||k r$| d¡ q$W | j	 
|¡ |j| jdd | d¡ d S )NrÃ  r   zcase %s:zCYTHON_FALLTHROUGH;F)rË  zbreak;)rH   r¯  rÂ   rÀ   r  rO   r   rÎ   r%   r“   rÄ   )r~   rU   Znum_conditionsZline_tracing_enabledr(  r$  r&   r&   r'   rÄ   å  s    
z&SwitchCaseNode.generate_execution_codec             C   s.   x| j D ]}| ||¡ qW | j ||¡ d S )N)r¯  rÃ   r“   )r~   rA   rU   r$  r&   r&   r'   rÃ   ò  s    z,SwitchCaseNode.generate_function_definitionsc             C   s*   x| j D ]}| |¡ qW | j |¡ d S )N)r¯  r”   r“   )r~   rU   r$  r&   r&   r'   r”   ÷  s    zSwitchCaseNode.annotateN)rK   rk   rl   r‰   r°  rÄ   rÃ   r”   r&   r&   r&   r'   r®  Ù  s
   r®  c               @   s.   e Zd ZdddgZdd„ Zdd„ Zdd	„ Zd
S )ÚSwitchStatNodeÚtestÚcasesr£  c             C   s¼   | j  |¡ x| jD ]}| |¡ qW | | j¡ | d| j  ¡  ¡ x| jD ]}| |¡ qNW | j	d k	rŒ| d¡ | j	 |¡ | d¡ n
| d¡ | d¡ | j  
|¡ | j  |¡ d S )Nzswitch (%s) {zdefault:zbreak;zdefault: break;rÉ  )r²  rI  r³  r°  rÎ   r%   rO   r   rÄ   r£  r  rP  )r~   rU   Úcaser&   r&   r'   rÄ     s    



z&SwitchStatNode.generate_execution_codec             C   sF   | j  ||¡ x| jD ]}| ||¡ qW | jd k	rB| j ||¡ d S )N)r²  rÃ   r³  r£  )r~   rA   rU   r´  r&   r&   r'   rÃ     s
    
z,SwitchStatNode.generate_function_definitionsc             C   s@   | j  |¡ x| jD ]}| |¡ qW | jd k	r<| j |¡ d S )N)r²  r”   r³  r£  )r~   rU   r´  r&   r&   r'   r”   $  s
    
zSwitchStatNode.annotateN)rK   rk   rl   r‰   rÄ   rÃ   r”   r&   r&   r&   r'   r±  ý  s   
r±  c               @   s   e Zd ZdS )ÚLoopNodeN)rK   rk   rl   r&   r&   r&   r'   rµ  ,  s   rµ  c               @   s>   e Zd ZdddgZdd„ Zdd„ Zdd	„ Zd
d„ Zdd„ ZdS )ÚWhileStatNoder¬  r“   r£  c             C   s"   | j  |¡ | jr| j |¡ d S )N)r“   r   r£  )r~   rA   r&   r&   r'   r   9  s    z"WhileStatNode.analyse_declarationsc             C   s:   | j r| j  |¡| _ | j |¡| _| jr6| j |¡| _| S )N)r¬  r­  r“   rp   r£  )r~   rA   r&   r&   r'   rp   >  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É  z
/*else*/ {)rÎ   r%   Únew_loop_labelsrO   r¬  rI  r  r   rP  r“   rÄ   r  r  r‹  Úset_loop_labelsr£  )r~   rU   Úold_loop_labelsr‹  r&   r&   r'   rÄ   F  s*    



z%WhileStatNode.generate_execution_codec             C   s>   | j r| j  ||¡ | j ||¡ | jd k	r:| j ||¡ d S )N)r¬  rÃ   r“   r£  )r~   rA   rU   r&   r&   r'   rÃ   ]  s
    
z+WhileStatNode.generate_function_definitionsc             C   s4   | j r| j  |¡ | j |¡ | jr0| j |¡ d S )N)r¬  r”   r“   r£  )r~   rU   r&   r&   r'   r”   d  s
    zWhileStatNode.annotateN)	rK   rk   rl   r‰   r   rp   rÄ   rÃ   r”   r&   r&   r&   r'   r¶  0  s   
r¶  c            
   @   s\   e Zd Zddddddddd	d
g
Zd ZZd ZZd ZZ	dd„ Z
dd„ Zdd„ Zdd„ ZdS )ÚDictIterationNextNodeÚdict_objÚexpected_sizeÚpos_index_varÚcoerced_key_varÚcoerced_value_varÚcoerced_tuple_varÚ
key_targetÚvalue_targetÚtuple_targetÚis_dict_flagNc             C   s(   t j| |j|||||||dtjd d S )NT)	r»  r¼  r½  rÁ  rÂ  rÃ  rÄ  rG  r/   )r{   r€   r%   r
   Úc_bint_type)r~   r»  r¼  r½  rÁ  rÂ  rÃ  rÄ  r&   r&   r'   r€   x  s    zDictIterationNextNode.__init__c             C   s  ddl m} | j |¡| _| j |¡| _| jr<| j |¡| _| jrx| j |¡| _| | jj	t
j¡| _| j | jj|¡| _| jr¶| j |¡| _|j| jj	t
jd| _| j | jj|¡| _| jrò| j |¡| _| | jj	t
j¡| _| j | jj|¡| _| j |¡| _| S )Nr   )rô   )r/   )r«   rô   r»  ro   r¼  r½  rÁ  rq   ÚTempNoder%   r
   r   Úkey_refr"  r/   r¾  rÂ  Ú	value_refr¿  rÃ  Ú	tuple_refrÀ  rÄ  )r~   rA   rô   r&   r&   r'   rp   †  s&    z)DictIterationNextNode.analyse_expressionsc             C   s   | j  ||¡ d S )N)r»  rÃ   )r~   rA   rU   r&   r&   r'   rÃ   ›  s    z3DictIterationNextNode.generate_function_definitionsc       	      C   sœ  |j  t dd¡¡ | j |¡ g }g }xz| j| j| jf| j	| j
| jf| j| j| jfgD ]H\}}}|d krpd}n&| |||f¡ | |¡ d| ¡  }| |¡ qXW |j tjd¡}| d|| j ¡ | j ¡ | j ¡ |d |d |d	 | j ¡ f ¡ | d
| ¡ | | d| | j¡¡ |j |¡ x"|D ]\}}}| | ¡ ¡ q.W x|D ]\}}}| |¡ qRW x*|D ]"\}}}| ||¡ |  |¡ qrW d S )NZ	dict_iterz
Optimize.crm  z&%sFz7%s = __Pyx_dict_iter_next(%s, %s, &%s, %s, %s, %s, %s);r   r   r"   zif (unlikely(%s == 0)) break;z%s == -1)!rÂ   rl  r   rÔ  r»  rI  rÇ  r¾  rÁ  rÈ  r¿  rÂ  rÉ  rÀ  rÃ  r  Úallocater   r¦  r§  r
   r=   rO   r„  r¼  r½  rÄ  Úerror_goto_ifr%   r­  rª  rS  Úrelease)	r~   rU   rj  Ztemp_addressesrE  r   rQ  ÚaddrÚresult_tempr&   r&   r'   rÄ   ž  sB    
z-DictIterationNextNode.generate_execution_code)rK   rk   rl   r‰   r¾  rÇ  r¿  rÈ  rÀ  rÉ  r€   rp   rÃ   rÄ   r&   r&   r&   r'   rº  l  s   rº  c               @   sD   e Zd ZddddddgZd ZZdd	„ Zd
d„ Zdd„ Zdd„ Z	dS )ÚSetIterationNextNodeÚset_objr¼  r½  r¿  rÂ  Úis_set_flagNc             C   s$   t j| |j|||||dtjd	 d S )NT)rÐ  r¼  r½  rÂ  rÑ  rG  r/   )r{   r€   r%   r
   rÅ  )r~   rÐ  r¼  r½  rÂ  rÑ  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 )Nr   )rô   )r/   )r«   rô   rÐ  ro   r¼  r½  rÂ  rq   rÆ  r%   r
   r   rÈ  r"  r/   r¿  rÑ  )r~   rA   rô   r&   r&   r'   rp   Û  s    z(SetIterationNextNode.analyse_expressionsc             C   s   | j  ||¡ d S )N)rÐ  rÃ   )r~   rA   rU   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_iterz
Optimize.cFz/%s = __Pyx_set_iter_next(%s, %s, &%s, &%s, %s);zif (unlikely(%s == 0)) break;z%s == -1)rÂ   rl  r   rÔ  rÐ  rI  rÈ  rÊ  r¦  r§  r
   r=   rO   r„  r¼  r   r½  rÑ  rË  r%   r­  rª  r¿  rÂ  rS  rÌ  )r~   rU   rÈ  rÎ  r&   r&   r'   rÄ   é  s&    
z,SetIterationNextNode.generate_execution_code)
rK   rk   rl   r‰   r¿  rÈ  r€   rp   rÃ   rÄ   r&   r&   r&   r'   rÏ  È  s   
rÏ  c             K   s<   d|kr,|d j rt| f|ŽS t| f|ŽS nt| f|ŽS d S )NÚiterator)Úis_asyncÚAsyncForStatNodeÚForInStatNodeÚForFromStatNode)r%   r   r&   r&   r'   ÚForStatNode  s
    
r×  c               @   sR   e Zd ZdddddgZdZdZdd	„ Zd
d„ Zdd„ Zdd„ Z	dd„ Z
dd„ ZdS )Ú_ForInStatNoderQ  r   rÒ  r“   r£  NFc             C   s   t dƒ‚d S )Nz!must be implemented by subclasses)ÚNotImplementedError)r~   r&   r&   r'   Ú_create_item_node  s    z _ForInStatNode._create_item_nodec             C   s6   | j  |¡ | j |¡ | jr*| j |¡ |  ¡  d S )N)rQ  r  r“   r   r£  rÚ  )r~   rA   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 )N)rQ  rq   rÒ  rp   rÚ  r   rÓ  r/   rÝ   rÞ   r#  r"  r“   r£  )r~   rA   r&   r&   r'   rp   &  s    z"_ForInStatNode.analyse_expressionsc             C   s  |  | j¡ | ¡ }| j |¡ | d¡ | j |¡ | j | j|¡ | j	 
|¡ |  | j¡ | |j¡ | d¡ |j}| |¡ | jrR|j|jf}| d¡|_| d¡|_| d¡ | j 
|¡ | d¡ | jj }xlt|j|jg|ƒD ]V\}}| |¡sqî|r| |¡ d}|  | j¡ | |¡ | j |¡ | |¡ qîW | |¡ |  | j¡ | |¡rt| |¡ | j |¡ | j |¡ d S )Nz
for (;;) {rÉ  Zouter_continueZouter_breakz
/*else*/ {F)rÎ   r%   r·  rÒ  rI  rO   r   rQ  rS  r“   rÄ   r  r  r‹  r¸  r£  rÖ  r¹   rB  r¹  r  r  rP  )r~   rU   r¹  r‹  Zorig_exit_labelsZneeds_goto_endÚ
exit_labelZorig_exit_labelr&   r&   r'   rÄ   7  sH    









z&_ForInStatNode.generate_execution_codec             C   sF   | j  ||¡ | j ||¡ | j ||¡ | jd k	rB| j ||¡ d S )N)rQ  rÃ   rÒ  r“   r£  )r~   rA   rU   r&   r&   r'   rÃ   d  s
    
z,_ForInStatNode.generate_function_definitionsc             C   sF   | j  |¡ | j |¡ | j |¡ | jr6| j |¡ | j |¡ d S )N)rQ  r”   rÒ  r“   r£  r   )r~   rU   r&   r&   r'   r”   k  s    z_ForInStatNode.annotate)rK   rk   rl   r‰   r   rÓ  rÚ  r   rp   rÄ   rÃ   r”   r&   r&   r&   r'   rØ    s   
-rØ  c               @   s   e Zd ZdZdd„ ZdS )rÕ  Fc             C   s   ddl m} || jƒ| _d S )Nr   )ÚNextNode)rô   rÜ  rÒ  r   )r~   rÜ  r&   r&   r'   rÚ  y  s    zForInStatNode._create_item_nodeN)rK   rk   rl   rÓ  rÚ  r&   r&   r&   r'   rÕ  t  s   rÕ  c               @   s    e Zd ZdZdd„ Zdd„ ZdS )rÔ  Tc             K   sD   d|kst ‚ddlm} |j|d jd d|d< tj| |f|Ž d S )Nr   r   )rô   rÒ  )r9  )r  r«   rô   ZAwaitIterNextExprNoder%   rØ  r€   )r~   r%   r   rô   r&   r&   r'   r€   †  s    zAsyncForStatNode.__init__c             C   s    ddl m} | | j¡| j_d S )Nr   )rô   )r«   rô   ZAsyncNextNoderÒ  r   r9  )r~   rô   r&   r&   r'   rÚ    s    z"AsyncForStatNode._create_item_nodeN)rK   rk   rl   rÓ  r€   rÚ  r&   r&   r&   r'   rÔ  ~  s   rÔ  c               @   sv   e Zd ZddddddgZdZdZdZdZd	Zd
d„ Z	dd„ Z
dd„ Zdd„ Zdd„ ZdddddœZdd„ Zdd„ ZdS )rÖ  rQ  Úbound1Úbound2Ústepr“   r£  FNz&For-loop using object bounds or targetc             C   s.   x(| j | j| jfD ]}|jjr|  ¡  qW d S )N)rQ  rÝ  rÞ  r/   r;   r‚   )r~   rA   r‡   r&   r&   r'   r½   ­  s    zForFromStatNode.nogil_checkc             C   s.   | j  |¡ | j |¡ | jr*| j |¡ d S )N)rQ  r  r“   r   r£  )r~   rA   r&   r&   r'   r   ²  s    z$ForFromStatNode.analyse_declarationsc             C   s¾   ddl m} | j |¡| _| j |¡| _| j |¡| _| jd k	rlt| j|j	ƒr^t
| jjddƒ | j |¡| _|  |¡ | jj}|js˜|js˜t| jjdƒ | j |¡| _| jrº| j |¡| _| S )Nr   )rô   zdProbable infinite loop in for-from-by statement. Consider switching the directions of the relations.r"   z>for-from loop variable must be c numeric type or Python object)r«   rô   rQ  rq   rÝ  ro   rÞ  rß  rI   ZUnaryMinusNoder   r%   Úset_up_loopr/   r;   rb  r   r“   rp   r£  )r~   rA   rô   rþ  r&   r&   r'   rp   ¸  s"    


z#ForFromStatNode.analyse_expressionsc             C   s|  ddl m} | jj}|jr |}n~|jr4t| jjdƒ |jr@t	j
nt	j}| jjjs`t	 || jj¡}| jjjszt	 || jj¡}| jd k	rž| jjjsžt	 || jj¡}| j ||¡| _| j ||¡| _| jjsÔ| j |¡| _| jd k	r| j ||¡| _| jjs| j |¡| _|js|jrJd| _t| j|jƒr:t| jdƒ‚| j| _d | _n.d| _| | j||¡}|| _| |¡ |¡| _d S )Nr   )rô   zWInteger loops over enum values are fragile. Please cast to a safe integer type instead.FzEBuffer or memoryview slicing/indexing not allowed as for-loop target.T)r«   rô   rQ  r/   rb  Úis_enumr   r%   r;   r
   r<   r=   rÝ  Úwidest_numeric_typerÞ  rß  r"  r¸   r\  Úis_py_targetrI   ZBufferIndexNoder   Úloopvar_nodeÚpy_loopvar_noderÆ  rq  r€  )r~   rA   rô   rþ  Z	loop_typeZc_loopvar_noder&   r&   r'   rà  Í  s@    


zForFromStatNode.set_up_loopc             C   s  |  | j¡ | ¡ }| j}| j |¡ | j |¡ | j| j \}}| j	d k	rt| j	 |¡ | j	 
¡ }d|d |f }nd}ddlm} t| j|jƒrž| j |¡ t| j|jƒr¸| j |¡ | jjjrÈtjn| jj}|rê| jsê|j |d¡}	n
| j 
¡ }	|jrF|jsF| jd dkrF| d|	| j 
¡ |||	| j| j 
¡ ||	|f
 ¡ n,| d	|	| j 
¡ ||	| j| j 
¡ |	|f ¡ | j}
|
d krš|rš| | jj||	¡}
|
d k	r¼|
 |¡ | j |
|¡ | j  !|¡ | "|j#¡ |sô| jrô| jj$j%rž| &| jjd ¡}| |¡ | '| jj$j(¡}| jj$j)j*r@|j+ ,t- .d
d¡¡ d}n&|j+ ,t- .dd¡¡ d /| jj$j)j0¡}| || 
¡ || 1| 
¡ | jj¡f ¡ | 2| 
¡ ¡ n| j}| 3| jj|| jj$j)¡}|	|_4| 5|¡ | jj$j%rô| 6| 
¡ |j¡ | 7|¡ | d¡ |s(| jr(| j |¡ | j | j|¡ |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 k	r| j	 <|¡ | j	 =|¡ d S )Nz%s=%sr   Ú1r   )rô   Fú>z-for (%s = %s%s + %s; %s %s %s + %s; ) { %s%s;z!for (%s = %s%s; %s %s %s; %s%s) {ZGetModuleGlobalNamezObjectHandling.cz%__Pyx_GetModuleGlobalName(%s, %s); %sZGetNameInClassz$__Pyx_GetNameInClass(%s, {}, %s); %srÉ  z
/*else*/ {)>rÎ   r%   r·  Ú
from_rangerÝ  rI  rÞ  Úrelation_tableZ	relation1rß  r   r«   rô   rI   rä  rÆ  rÊ  rå  rQ  r/   rá  r
   r<   rã  r¦  r§  rø   r]  Z	relation2rO   r  rS  r“   rÄ   r  r  rÇ   Zis_pyglobalZ
PyTempNoderÇ  r:   r0  r‰  rÂ   rl  r   rÔ  Úformatr  r©  rª  ZCoerceFromPyTypeNodeZ	temp_codeÚgenerate_result_coder  rÌ  r­  r‹  r¸  r£  r  rP  )r~   rU   r¹  rè  ÚoffsetZincoprß  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++)z+1z++)r«   z--)z-1z--)z<=rÉ  z>=rç  c             C   sl   | j  ||¡ | j ||¡ | j ||¡ | jd k	rB| j ||¡ | j ||¡ | jd k	rh| j ||¡ d S )N)rQ  rÃ   rÝ  rÞ  rß  r“   r£  )r~   rA   rU   r&   r&   r'   rÃ   l  s    

z-ForFromStatNode.generate_function_definitionsc             C   sX   | j  |¡ | j |¡ | j |¡ | jr6| j |¡ | j |¡ | jrT| j |¡ d S )N)rQ  r”   rÝ  rÞ  rß  r“   r£  )r~   rU   r&   r&   r'   r”   v  s    zForFromStatNode.annotate)rK   rk   rl   r‰   rã  rä  rå  rè  r   r½   r   rp   rà  rÄ   ré  rÃ   r”   r&   r&   r&   r'   rÖ  ’  s"   &s
rÖ  c               @   sD   e Zd ZdZddddgZdZdZdd„ Zd	d
„ Zdd„ Z	dd„ Z
dS )ÚWithStatNodea  
    Represents a Python with statement.

    Implemented by the WithTransform as follows:

        MGR = EXPR
        EXIT = MGR.__exit__
        VALUE = MGR.__enter__()
        EXC = True
        try:
            try:
                TARGET = VALUE  # optional
                BODY
            except:
                EXC = False
                if not EXIT(*EXCINFO):
                    raise
        finally:
            if EXC:
                EXIT(None, None, None)
            MGR = EXIT = VALUE = None
    ÚmanagerÚ
enter_callrQ  r“   Nc             C   s(   | j  |¡ | j |¡ | j |¡ d S )N)rî  r   rï  r“   )r~   rA   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   )rÆ  )rî  ro   rï  rQ  rô   rÆ  r%   r/   Útarget_tempr“   rp   )r~   rA   rÆ  r&   r&   r'   rp   ¨  s    z WithStatNode.analyse_expressionsc             C   s.   | j  ||¡ | j ||¡ | j ||¡ d S )N)rî  rÃ   rï  r“   )r~   rA   rU   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:*/ {F)r¥  ZPyObjectLookupSpecialzObjectHandling.cz-%s = __Pyx_PyObject_LookupSpecial(%s, %s); %sÚ	__aexit__Ú__exit__z%s = %s;rÉ  )&rÎ   r%   rO   rî  rI  r¦  r§  r   Zexit_varrÂ   rl  r   rÔ  r„  rÇ  r   rÓ  r©  rª  r¶  r  rï  rQ  rð  rÊ  rL  r   rO  r  rP  r“   rÄ   r¹  rÖ  r  r  r¬  r­  )r~   rU   r½  Zintermediate_error_labelZstep_over_labelr&   r&   r'   rÄ   ·  sF    




z$WithStatNode.generate_execution_code)rK   rk   rl   rx   r‰   rï  rð  r   rp   rÃ   rÄ   r&   r&   r&   r'   rí    s   
rí  c               @   s<   e Zd ZddgZdZdZdd„ Zdd„ Zdd	„ Zd
d„ Z	dS )ÚWithTargetAssignmentStatNoderJ  r!  Nc             C   s   | j  |¡ d S )N)r!  r  )r~   rA   r&   r&   r'   r   ö  s    z1WithTargetAssignmentStatNode.analyse_declarationsc             C   s4   | j  |¡| _ | j  |¡ | jj | j j|¡| _| S )N)r!  rq   rX  Ú	with_noderð  r"  r/   rJ  )r~   rA   r&   r&   r'   rp   ù  s    z0WithTargetAssignmentStatNode.analyse_expressionsc             C   s.   | j  |¡ | j | j |¡ | jj |¡ d S )N)rJ  rI  r!  rS  rô  rð  rÌ  )r~   rU   r&   r&   r'   rÄ   ÿ  s    z4WithTargetAssignmentStatNode.generate_execution_codec             C   s   | j  |¡ | j |¡ d S )N)r!  r”   rJ  )r~   rU   r&   r&   r'   r”     s    z%WithTargetAssignmentStatNode.annotate)
rK   rk   rl   r‰   rô  rJ  r   rp   rÄ   r”   r&   r&   r&   r'   ró  è  s   
ró  c               @   sL   e Zd ZdddgZdZdd„ Zdd„ ZejZ	d	Z
d
d„ Zdd„ Zdd„ ZdS )ÚTryExceptStatNoder“   Úexcept_clausesr£  Fc             C   s<   | j  |¡ x| jD ]}| |¡ qW | jr8| j |¡ d S )N)r“   r   rö  r£  )r~   rA   Úexcept_clauser&   r&   r'   r     s
    z&TryExceptStatNode.analyse_declarationsc             C   sv   | j  |¡| _ d}xDt| jƒD ]6\}}| |¡ }| j|< |rJt|jdƒ |jsd}qW || _| jrr| j |¡| _| S )Nr   zdefault 'except:' must be lastr   )	r“   rp   r  rö  r   r%   ÚpatternÚhas_default_clauser£  )r~   rA   Zdefault_clause_seenr(  r÷  r&   r&   r'   rp     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 ¡ }ˆ  |¡}|rvˆ j t¡ | js.| d¡ | d¡ | dd dd
„ ˆD ƒ¡ ¡ xˆD ]}| |¡ qRW ‡ ‡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*xˆD ]}ˆ  |t¡ q
W ˆ  |¡ ˆ  |¡ x|D ]\}}ˆ  ||¡ q:W ˆ jj}| ˆ j_x| jD ]}| ˆ |¡ qlW |ˆ j_| jsœˆ  |¡ xˆ||f||f||f|
|f|	|fgD ]b\}}ˆ  |¡rÀ|sðˆ  |¡sðˆ  |¡ ˆ  |¡ ˆ j | jdd |r|ƒ  ˆ  |¡ qÀW ˆ  |¡rd|sNˆ  |¡sNˆ  |¡ ˆ  |¡ |rd|ƒ  ˆ  |¡rzˆ  |¡ ˆ  d¡ xˆD ]}ˆ j  |¡ qŠW |ˆ _|ˆ _|ˆ _|ˆ _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|  )rU   r&   r'   rˆ   <  s   z=TryExceptStatNode.generate_execution_code.<locals>.<listcomp>r$   z
/*try:*/ {F)rË  rÉ  rÌ  rÍ  z__Pyx_ExceptionSave(%s);z, c             S   s   g | ]}d | ‘qS )z&%sr&   )r†   rE  r&   r&   r'   rˆ   R  s    c                 s0   xˆD ]} ˆ   | ¡ qW ˆ  dd ˆ¡ ¡ d S )Nz__Pyx_ExceptionReset(%s);z, )r  rO   r¡   )r:   )rU   Úexc_save_varsr&   r'   Úrestore_saved_exceptionV  s    
zJTryExceptStatNode.generate_execution_code.<locals>.restore_saved_exceptionc             S   s   g | ]}d | ‘qS )z	(void)%s;r&   )r†   rE  r&   r&   r'   rˆ   ^  s    z%s /* mark used */rF   c               S   s   d S )Nr&   r&   r&   r&   r'   rû  a  s    z/*else:*/ {)!rÎ   r%   rO   r  r‹  r  r¶  r  rÖ  ri  rä  r“   rÄ   r¦  Úall_free_managed_tempsr¹  rÂ   rl  Úreset_exception_utility_coder  r¡   Úput_xgotrefr¹   r£  rÄ  r   r  r  Zcurrent_exceptrö  Úgenerate_handling_coderù  r­  )r~   rU   Ú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_raiserE  rû  Zmark_vars_usedZnormal_case_terminatesÚ	temp_nameÚ	temp_typeZouter_exceptr÷  rÛ  Ú	old_labelr  r&   )rU   rú  r'   rÄ   +  sÀ    






















z)TryExceptStatNode.generate_execution_codec             C   sF   | j  ||¡ x| jD ]}| ||¡ qW | jd k	rB| j ||¡ d S )N)r“   rÃ   rö  r£  )r~   rA   rU   r÷  r&   r&   r'   rÃ   ¤  s
    
z/TryExceptStatNode.generate_function_definitionsc             C   s<   | j  |¡ x| jD ]}| |¡ qW | jr8| j |¡ d S )N)r“   r”   rö  r£  )r~   rU   Zexcept_noder&   r&   r'   r”   «  s
    zTryExceptStatNode.annotateN)rK   rk   rl   r‰   r  r   rp   r{   r‚   r½   r   rÄ   rÃ   r”   r&   r&   r&   r'   rõ  	  s   
yrõ  c               @   sL   e Zd ZddddgZdZdZdZdd„ Zd	d
„ Zdd„ Z	dd„ Z
dd„ ZdS )ÚExceptClauseNoderø  rQ  r“   r•  NFc             C   s"   | j r| j  |¡ | j |¡ d S )N)rQ  r  r“   r   )r~   rA   r&   r&   r'   r   Ê  s    z%ExceptClauseNode.analyse_declarationsc             C   s„   |j | _| jr@x0t| jƒD ]"\}}| |¡}| |¡| j|< qW | jrrddlm} | 	| j
¡| _| j || j¡| _| j |¡| _| S )Nr   )rô   )r  Úfunction_namerø  r  rp   r€  rQ  r«   rô   ZExcValueNoder%   r•  r  r“   )r~   rA   r(  rø  rô   r&   r&   r'   rp   Ï  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 }x*| jD ] }| ˆ ¡ | || ¡  ¡ q´W ˆ jjtjdd}ˆ  	d|d |¡f ¡ x$| jD ]}| ˆ ¡ | ˆ ¡ q
W |rvˆ  	dt
|ƒ ¡ ˆ  	d dd„ |D ƒ¡¡ x|D ]}	ˆ j |	¡ q`W ˆ  	d| ¡ ˆ j |¡ n
ˆ  	d¡ t| jddƒsú| jd krú| jd krúˆ j t dd¡¡ ˆ  	d¡ ˆ  |¡ ˆ  	d¡ d S ‡ fdd„tdƒD ƒ}ˆ  | j¡ ˆ j t¡ dt
|ƒ }
ˆ  	d|
ˆ  | j¡f ¡ x|D ]}ˆ  |¡ qTW | jrœ| j  !|d  ¡ | j  ˆ ¡ | j "| j ˆ ¡ | jd k	rÐx&t#|| jj$ƒD ]\}}| !|¡ q¸W ˆ j%ˆ j& }}ˆ  'd!¡ˆ _%ˆ  'd"¡ˆ _&ˆ jj(}|ˆ j_(| j )ˆ ¡ |ˆ j_(| jj*sJx|D ]}ˆ  +|t,¡ q*W ˆ  |¡ x^ˆ j%|fˆ j&|fgD ]F\}}ˆ  -|¡r`ˆ  .|¡ x|D ]}ˆ  /|t,¡ q„W ˆ  |¡ q`W |ˆ _%|ˆ _&x|D ]}	ˆ j |	¡ q¼W ˆ  	d¡ d S )#Nc             s   s$   | ]}|j p| ¡ o|j V  qd S )N)r¸   Ú	is_simplerG  )r†   rø  r&   r&   r'   rÓ   ä  s   z:ExceptClauseNode.generate_handling_code.<locals>.<genexpr>c                s   g | ]}ˆ j jtd d‘qS )T)r¥  )r¦  r§  r   )r†   r|  )rU   r&   r'   rˆ   é  s   z;ExceptClauseNode.generate_handling_code.<locals>.<listcomp>r$   ÚPyErrFetchRestorezExceptions.cz__Pyx_ErrFetch(&%s, &%s, &%s);ZFastTypeCheckszModuleSetupCode.cz*__Pyx_PyErr_GivenExceptionMatches(%s, %%s)r   r&   ZPyErrExceptionMatchesz __Pyx_PyErr_ExceptionMatches(%s)F)r¥  z%s = %s;z || z__Pyx_ErrRestore(%s, %s, %s);rF   c             S   s   g | ]}d | ‘qS )z%s = 0;r&   )r†   rE  r&   r&   r'   rˆ     s    z	if (%s) {z/*except:*/ {rË   Tz__Pyx_ErrRestore(0,0,0);rÉ  c                s   g | ]}ˆ j jtd d‘qS )T)r¥  )r¦  r§  r   )r†   r|  )rU   r&   r'   rˆ     s   z&%s, &%s, &%sz"if (__Pyx_GetException(%s) < 0) %sr   Zexcept_breakZexcept_continue)0rÎ   r%   rø  rÕ   ri  rÂ   rl  r   rÔ  rO   rÌ  rI  r  r„  r¦  r§  r
   r=   r¡   r  rP  r­  rŠ   r“   Úexcinfo_targetrQ  r  r  r  Úget_exception_utility_coder«  rª  r•  Zset_varrS  rB  rR   r‹  r  rÖ  rž  rÄ   r¹   rÄ  r   r¹  r  r¬  )r~   rU   r¿  Zhas_non_literalsrž  Zexc_test_funcZ	exc_testsrø  Z
match_flagr®  Zexc_argsrE  ZtempvarrT   r  r  Úold_exc_varsrÖ  r  r&   )rU   r'   rÿ  ß  s¤    
















z'ExceptClauseNode.generate_handling_codec             C   s*   | j d k	r| j  ||¡ | j ||¡ d S )N)rQ  rÃ   r“   )r~   rA   rU   r&   r&   r'   rÃ   K  s    
z.ExceptClauseNode.generate_function_definitionsc             C   sB   | j r x| j D ]}| |¡ qW | jr2| j |¡ | j |¡ d S )N)rø  r”   rQ  r“   )r~   rU   rø  r&   r&   r'   r”   P  s    zExceptClauseNode.annotate)rK   rk   rl   r‰   r•  r  Zis_except_asr   rp   rÿ  rÃ   r”   r&   r&   r&   r'   r  ³  s   lr  c               @   sˆ   e Zd ZdddgZdZdZdZdZdZdZ	e
dd	„ ƒZd
d„ Zdd„ ZejZdZdd„ Zdd„ Zddd„Zddd„Zdd„ Zdd„ ZdS )ÚTryFinallyStatNoder“   Úfinally_clauseÚfinally_except_clauser   TNFc             C   s   t | ||d}|S )N)r“   r  )r  )r%   rA   r“   r  rT   r&   r&   r'   rÌ   s  s    z"TryFinallyStatNode.create_analysedc             C   s6   | j  |¡ t | j¡| _| j |¡ | j |¡ d S )N)r“   r   r   Údeepcopyr  r  )r~   rA   r&   r&   r'   r   x  s    z'TryFinallyStatNode.analyse_declarationsc             C   sD   | j  |¡| _ | j |¡| _| j |¡| _|jr@|jjs@|j| _| S )N)r“   rp   r  r  r   rà   Úfunc_return_type)r~   rA   r&   r&   r'   rp   ~  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¡ |rXˆ !ˆ |||¡ |r<x|D ]}ˆ j "|¡ q&W |rNˆ j "|¡ ˆ  |¡ xLt#ˆ  ¡ |ƒD ]:\}}ˆ  |¡s€qhˆ  |¡ ˆ $ˆ |¡ ˆ  |¡ qhW x|D ]}ˆ j "|¡ q¬W ˆ  d¡ ˆ  |¡ ˆ j%}d}xœt&t#||ƒƒD ]ˆ\}\}}ˆ  |¡sqò||kr$|
r$qòˆ  d| ¡ d }||krØˆjrpt‡ fdd„tdƒD ƒƒ}ˆ ˆ g |¡ ˆjjsØˆj'rØˆjsØt(ˆjt)ƒsØˆ jjˆj'dd}ˆ  d|t*j+f ¡ ˆj'j,rØˆ  dt*j+ ¡ |	ƒ  ˆ ¡ ||kr\|r,ˆ  dt*j+|f ¡ ˆj'j,r ˆ  d| ¡ ˆ j "|¡ ˆjr\ˆ !ˆ |¡ x|D ]}ˆ j "|¡ qFW ˆjjspˆ  |¡ ˆ  d¡ qòW ˆ  |¡ ˆ  d¡ d S )Nz
/*try:*/ {r   rÉ  z/*finally:*/ {c                s.   | d }t  |¡}|ˆ jkr&|| d< n|}|S )Nr   )r   r  r  )Ú_nextrT   Z	node_copy)r~   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 )F)r¥  )r¦  r§  r
   r=   )r†   r|  )rU   r&   r'   rˆ   Á  s   z>TryFinallyStatNode.generate_execution_code.<locals>.<listcomp>r"   F)r¥  c                s   g | ]}ˆ j jtd d‘qS )F)r¥  )r¦  r§  r   )r†   r|  )rU   r&   r'   rˆ   É  s   é   rÎ  r$   r&   z%s: {c                s   g | ]}ˆ j jtd d‘qS )F)r¥  )r¦  r§  r   )r†   r|  )rU   r&   r'   rˆ   ú  s   z%s = %s;z%s = 0;)-rÎ   r%   rO   r  Zall_new_labelsÚget_all_labelsÚhandle_error_caserÖ  r¦  Zin_try_finallyr“   rÄ   rü  r  Úset_all_labelsÚpreserve_exceptionr¹  r¹   r  r  r  Úis_try_finally_in_nogilré  rÌ  ri  r§  r
   ZCPtrTyper;  r!  Úput_error_catcherrž  r  Úput_error_uncatcherr­  rB  Úput_error_cleanerr  r  r  rI   ÚGILExitNoder	   rã  r;   )r~   rU   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  r  rÖ  r  r  r(  Zret_tempr&   )rU   r~   r'   rÄ   ‰  sâ    

























 









z*TryFinallyStatNode.generate_execution_codec             C   s4   | j  ||¡ | j ||¡ | jr0| j ||¡ d S )N)r“   rÃ   r  r  )r~   rA   rU   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 ƒ¡¡ x|D ]\}}| 	||¡ q`W | d|dd …  ¡ | d	|d d… d
  ¡ x|D ]}| 
|¡ q®W |rì| d|d tj|d tj|tjf ¡ | jrú| ¡  d S )NF)ré  rÍ  rF   c             S   s   g | ]}d | ‘qS )z%s = 0;r&   )r†   rE  r&   r&   r'   rˆ   .  s    z8TryFinallyStatNode.put_error_catcher.<locals>.<listcomp>z>if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&%s, &%s, &%s);r$   zmif ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&%s, &%s, &%s) < 0)) __Pyx_ErrFetch(&%s, &%s, &%s);r"   z%s = %s; %s = %s; %s = %s;r   r   )rÂ   rl  r
  r  Úswap_exception_utility_coder  rè  rO   r¡   rÄ  rþ  r	   Úlineno_cnameÚclineno_cnameÚfilename_cnamer  )	r~   rU   r  rž  r  r   r  r/   rE  r&   r&   r'   r  $  s,    



z$TryFinallyStatNode.put_error_catcherc          	   C   s  |j  t¡ |j  t¡ | jr*|jdd | d¡ x|dd … D ]}| |¡ qBW | d|dd …  ¡ | d¡ x|d d… D ]}| |¡ q‚W | d|d d…  ¡ | jr¸| ¡  | d 	d	d
„ |D ƒ¡¡ |rþ| dt
j|d t
j|d t
j|f ¡ d S )NF)ré  zif (PY_MAJOR_VERSION >= 3) {r$   z!__Pyx_ExceptionReset(%s, %s, %s);rÉ  z__Pyx_ErrRestore(%s, %s, %s);rF   c             S   s   g | ]}d | ‘qS )z%s = 0;r&   )r†   rE  r&   r&   r'   rˆ   [  s    z:TryFinallyStatNode.put_error_uncatcher.<locals>.<listcomp>z%s = %s; %s = %s; %s = %s;r   r   )rÂ   rl  r
  rý  r  rè  rO   r  r  r¡   r	   r"  r#  r$  )r~   rU   rž  r  r   rE  r&   r&   r'   r  F  s(    



z&TryFinallyStatNode.put_error_uncatcherc             C   s¾   |j  t¡ | jr|jdd | d¡ x|dd … D ]}| |¡ q6W | d|dd …  ¡ | d¡ x |d d… D ]}| |t¡ qvW | jr˜| 	¡  | d 
dgd ¡|dd …  ¡ d S )	NF)ré  zif (PY_MAJOR_VERSION >= 3) {r$   z!__Pyx_ExceptionReset(%s, %s, %s);rÉ  rF   z%s = 0;)rÂ   rl  rý  r  rè  rO   r  rÄ  r   r  r¡   )r~   rU   rž  rE  r&   r&   r'   r  b  s    

z$TryFinallyStatNode.put_error_cleanerc             C   s   | j  |¡ | j |¡ d S )N)r“   r”   r  )r~   rU   r&   r&   r'   r”   t  s    zTryFinallyStatNode.annotate)NN)NN)rK   rk   rl   r‰   r  r  r  r  r  r  rÏ   rÌ   r   rp   r{   r‚   r½   r   rÄ   rÃ   r  r  r  r”   r&   r&   r&   r'   r  Y  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)rK   rk   rl   rx   r  r½   r&   r&   r&   r'   r%  y  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_temp)r“   r  )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Úgil)rô   )ZParseTreeTransformsr*  ZvisitchildrenZyieldsr
   Zc_gilstate_typeZc_threadstate_ptr_typer«   rô   rÆ  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_blockrç  rd   r&  r   )r~   rA   )rJ   r&   r'   r      s    
z GILStatNode.analyse_declarationsc             C   s:   |  t dd¡¡ |j}| jdk|_t | |¡}||_|S )NZForceInitThreadszModuleSetupCode.cr  )rl  r   rÔ  r  r'  r  rp   )r~   rA   Ú	was_nogilrT   r&   r&   r'   rp   §  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'  rè  Zput_release_gilr  rÄ   rÌ  Ú	end_block)r~   rU   r.  Zold_gil_configr&   r&   r'   rÄ   °  s"    

z#GILStatNode.generate_execution_code)
rK   rk   rl   r(  r€   r)  r   rp   rÄ   rm   r&   r&   )rJ   r'   r&  ‚  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 )Nr&   )r~   rA   r&   r&   r'   rp   Ô  s    zGILExitNode.analyse_expressionsc             C   s:   | j r| j  ¡ }nd }| jdkr,| |¡ n
| |¡ d S )Nr+  )r(  r   r'  r  Zput_acquire_gil)r~   rU   r.  r&   r&   r'   rÄ   ×  s    
z#GILExitNode.generate_execution_code)rK   rk   rl   rx   r‰   r(  rp   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 )NF)ré  )rè  )r~   rU   r&   r&   r'   rÄ   è  s    z%EnsureGILNode.generate_execution_codeN)rK   rk   rl   rx   rÄ   r&   r&   r&   r'   r1  ã  s   r1  c              C   s   ddl m}  | jS )Nr   )rh  )r«   rh  rm  )rh  r&   r&   r'   Úcython_view_utility_codeì  s    r2  c               C   s   t  dd¡S )NÚArrayAPIzarrayarray.h)r   rÔ  r&   r&   r&   r'   r/  ô  r0  r/  c               C   s   t  dd¡S )Nr3  zarrayarray.h)r   rÔ  r&   r&   r&   r'   r/  õ  r0  )zcpython.arrayzcpython.array.arrayzcython.view)Z__Pyx_patch_asyncioZPatchAsyncIOzCoroutine.c)Z__Pyx_patch_inspectZPatchInspectzCoroutine.c)Ú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krÖdd„ | j d¡D ƒ}|d }|j |¡}|}x2|dd … D ]"}| |¡}| 	||| j¡ |}qzW | j
rº| 	| j
|| j¡ qò| |¡ | 	||| j¡ n| j
pà| j}| 	||| j¡ | jtkr| t| j ƒ ¡ d S )	Nz$cimport only allowed at module levelr   r®   )Úrelative_levelr"  c             S   s   g | ]}t |ƒ‘qS r&   )r   )r†   r:   r&   r&   r'   rˆ     s    z8CImportStatNode.analyse_declarations.<locals>.<listcomp>r   )r‰  r   r%   Úfind_modulerç  Úis_absoluter(  rý  Zfind_submoduleÚdeclare_moduleÚas_namer4  Úutility_code_for_cimportsrl  )r~   rA   Úmodule_scoper>  Ztop_nameZtop_module_scoper:   Úsubmodule_scoper&   r&   r'   r     s,    


z$CImportStatNode.analyse_declarationsc             C   s   | S )Nr&   )r~   rA   r&   r&   r'   rp   %  s    z#CImportStatNode.analyse_expressionsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rÄ   (  s    z'CImportStatNode.generate_execution_codeN)rK   rk   rl   r‰   r9  r   rp   rÄ   r&   r&   r&   r'   r6    s
   r6  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}| |¡ x(| j	D ]\}}}}|dkr°x(t
|j ¡ ƒD ]\}}	| ||	|¡ q”W qn| |¡}	|	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|kr^| |pR||
| j¡ nt|d||f ƒ |	rn|p||}| ||	|¡ qnW | d¡s¨| d¡r|tkrÂ| t| ƒ ¡ x>| j	D ]4\}}}}d||f }|tkrÊ| t| ƒ ¡ qÊW d S )Nz$cimport only allowed at module levelr"  z3relative cimport beyond main package is not allowed)r7  r  r   r.  rN  r   )r/  r0  r1  r%   Úclass)r%   rç  F)Úrelative_tor%   Zabsolute_fallbackz%Name '%s' not declared in module '%s'ÚcpythonÚcythonz%s.%s)r‰  r   r%   r7  r  Úcountr8  rç  r4  Úimported_namesr‹   rÆ   rc   r5  r_  Údeclaration_matchesZ
redeclaredr7  r5  r)  rý  Úparent_moduler:  r’  r<  rl  )r~   rA   r=  rç  r%   r:   r;  r/  Z
local_namerÇ   r>  r|  Zfqnamer&   r&   r'   r   8  sL    






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   )rp  r/   r†  Zis_struct_or_unionr/  )r~   rÇ   r/  r/   r&   r&   r'   rF  f  s    
z'FromCImportStatNode.declaration_matchesc             C   s   | S )Nr&   )r~   rA   r&   r&   r'   rp   t  s    z'FromCImportStatNode.analyse_expressionsc             C   s   d S )Nr&   )r~   rU   r&   r&   r'   rÄ   w  s    z+FromCImportStatNode.generate_execution_code)rK   rk   rl   r‰   rç  r7  rE  r   rF  rp   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 )
ÚFromImportStatNoder3  r   c             C   sN   xH| j D ]>\}}|dkr<|js.t| jdƒ d S d|_d| _q| |¡ qW d S )Nr  z%import * only allowed at module levelr   )rc   r‰  r   r%   Zhas_import_starÚimport_starr  )r~   rA   r:   rQ  r&   r&   r'   r   ‡  s    z'FromImportStatNode.analyse_declarationsc       	   	   C   s\  ddl m} | j |¡| _| | jt¡| _g | _x$| j	D ]\}}|dkrˆx8|j
 	¡ D ]*\}}|jsX|jjrX| t dd¡¡ P qXW q:| |j¡}|jr|jj|krt|jdƒr|jj| jjjkrÌq:y0|j| jjj| j| jjd}|jj|jkrúw:W n tk
r   Y nX | |d ¡}|jtkr2d }n| j |j|¡}| j |||f¡ q:W | S )Nr   )rô   r  ZExtTypeTestzObjectHandling.crç  )r%   r7  )r«   rô   r3  rp   r  r%   r   r   Úinterned_itemsrc   rÆ   rp  r/   r†  rl  r   rÔ  r_  r:   rD  rç  r7   r8  rŸ   r  r•   r  r"  r  )	r~   rA   rô   r:   rQ  r|  rÇ   r3  Úcoerced_itemr&   r&   r'   rp   ’  s8    z&FromImportStatNode.analyse_expressionsc             C   s0  |  | j¡ | j |¡ | jrB| dtj| j ¡ | | j¡f ¡ |j	j
tdd}| j |¡ | jrx|j t dd¡¡ xŽ| jD ]„\}}}| d|| j ¡ | |¡| || j¡f ¡ | |¡ |d krØ| | j|¡ n | |¡ | |¡ | ||¡ | |t¡ q€W |j	 |¡ | j |¡ | j |¡ d S )Nzif (%s(%s) < 0) %s;T)r¥  Ú
ImportFromzImportExport.cz!%s = __Pyx_ImportFrom(%s, %s); %s)rÎ   r%   r3  rI  rI  rO   r	   r„  r«  r¦  r§  r   r   r  rJ  rÂ   rl  r   rÔ  rÇ  r©  rª  rS  Zallocate_temp_resultrë  r¬  r­  r  rP  )r~   rU   Z	item_tempr:   rQ  rK  r&   r&   r'   rÄ   µ  s<    


z*FromImportStatNode.generate_execution_codeN)rK   rk   rl   r‰   rI  r   rp   rÄ   r&   r&   r&   r'   rH  {  s
   	#rH  c               @   s   e Zd ZdZdZdS )ÚParallelNodez4
    Base class for cython.parallel constructs.
    N)rK   rk   rl   rx   r½   r&   r&   r&   r'   rM  ×  s   rM  c                   sH  e Zd ZdZddgZdZdZdZdZdZ	dZ
ejejejfZejejejfZejejejfZdZ‡ fdd„Zd	d
„ Zdd„ Zdd„ Zdd„ Zdd„ Zd;dd„Zdd„ Z dd„ Z!dd„ Z"dd„ Z#d<dd„Z$d d!„ Z%d"d#„ Z&d$d%„ Z'd&d'„ Z(d=d(d)„Z)d*d+„ Z*d,d-„ Z+d.d/„ Z,d0d1„ Z-d>d2d3„Z.d4Z/d5Z0d6e/e0f Z1d7d8„ Z2d9d:„ Z3‡  Z4S )?ÚParallelStatNodea  
    Base class for 'with cython.parallel.parallel():' and 'for i in prange():'.

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

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

    is_parallel is true for:

        #pragma omp parallel
        #pragma omp parallel for

    sections, but NOT for

        #pragma omp for

    We need this to determine the sharing attributes.

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

    args         tuple          the arguments passed to the parallel construct
    kwargs       DictNode       the keyword arguments passed to the parallel
                                construct (replaced by its compile time value)
    r“   Únum_threadsNFr   c                s<   t t| ƒj|f|Ž | d¡p i | _tƒ | _i | _g | _d S )Nrj  )	rd   rN  r€   r4  rj  ry   Úseen_closure_varsÚprivatesÚassigned_nodes)r~   r%   rs   )rJ   r&   r'   r€      s
    zParallelStatNode.__init__c          
   C   sJ  | j  |¡ d | _| jrüg }tƒ }xŠ| jjD ]~}|jj|krPt| j	d|jj ƒ | 
|jj¡ |jjdkr||jjsª|j| _q,| jr |jjdkr |jjsª|j| _q,| |¡ q,W || j_y| j |¡| _W n0 tk
rø } zt| jj	dƒ W d d }~X Y nX ni | _xB| j ¡ D ]4\}}|| jkr4t| j	d| ƒ nt| ||ƒ qW d S )Nz$Duplicate keyword argument found: %srO  Ú	chunksizez=Only compile-time values may be supplied as keyword argumentszInvalid keyword argument: %s)r“   r   rO  rs   ry   r6   r¦   r7   r   r%   r¨   r·   Ú	is_prangerS  r  rO  Ú	Exceptionrc   Úvalid_keyword_argumentsrŒ   )r~   rA   ÚpairsÚseenZdictitemrk  r   r"  r&   r&   r'   r   /   s4    

"z%ParallelStatNode.analyse_declarationsc             C   sì   | j r| j  |¡| _ | jr(| j |¡| _| j |¡| _|  |¡ | j d k	rè| jrr| jj d k	rr| jjsrt| jdƒ nJ| jrŽ| jjsŽt| jdƒ n.| j j	j
r¼| j jr¼| j  |¡dkr¼t| jdƒ | j  ¡ rÐ| j j	jrè| j  tj|¡ |¡| _ | S )Nz-num_threads already declared in outer sectionz;num_threads must be declared in the parent parallel sectionr   z.argument to num_threads must be greater than 0)rO  rp   rS  r“   Úanalyse_sharing_attributesÚparentrT  r   r%   r/   rø   r¸   rO  r	  r;   r"  r
   r=   r\  )r~   rA   r&   r&   r'   rp   U   s&    


z$ParallelStatNode.analyse_expressionsc             C   sn   xh| j  ¡ D ]Z\}\}}| jr<| js<|| jj kr<t|dƒ q| jsR|rRt|dƒ qd}|  ||||¡ qW 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)rj  rc   rT  Úis_parallelrZ  r   Úpropagate_var_privatization)r~   rA   rÇ   r%   r_  Úlastprivater&   r&   r'   rY  n   s    


z+ParallelStatNode.analyse_sharing_attributesc             C   sl   ||f| j |< |jjr$t|dƒ dS | jrh| jsF|| jjkrF| jj}n| j}|rh|sX|rh| ||||¡ dS )a
  
        Propagate the sharing attributes of a variable. If the privatization is
        determined by a parent scope, done propagate further.

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

        So the following cases propagate:

            sum is a reduction for all loops:

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

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

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

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

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

                sum = 0

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

                    #pragma omp parallel
                    with parallel:

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

                    # sum and j are well-defined here

                # sum and j are undefined here

            # sum and j are undefined here
        z9Memoryview slices can only be shared in parallel sectionsN)	rQ  r/   rŠ  r   rT  r[  rZ  rj  r\  )r~   rÇ   r%   r_  r]  rZ  r&   r&   r'   r\  ˆ   s    5

z,ParallelStatNode.propagate_var_privatizationc             C   s€   | j r| j  ||¡S |j| jkr&|jS |j |jd¡}| j |j¡ | j |¡ | j 	||jf¡ | 
d||jf ¡ ||_dS )zo
        Helper function that allocate a temporary for a closure variable that
        is assigned to.
        Tz%s = %s;N)rZ  Ú_allocate_closure_tempr  rP  r¦  r§  r/   r¨   Úmodified_entriesr  rO   )r~   rU   rÇ   r  r&   r&   r'   r^  Ï   s    z'ParallelStatNode._allocate_closure_tempc             C   st   d}xjt | j ¡ ƒD ]X\}\}}|s|r0||kr|j ¡ }|r|rP| d¡ d}| d|j|j |¡f ¡ qW d S )NTz4/* Initialize private variables to invalid values */Fz%s = %s;)ÚsortedrQ  rc   r/   Úinvalid_valuerO   r  rJ  )r~   rU   Úexcluderh  rÇ   r_  r]  ra  r&   r&   r'   Úinitialize_privates_to_nanå   s    


z+ParallelStatNode.initialize_privates_to_nanc             C   s0   | j }|jj}||j_| |¡ ||j_| ¡ S )N)Ú1begin_of_parallel_control_block_point_after_declsr¦  ÚownerrI  r   )r~   rU   r   rš   re  r&   r&   r'   Úevaluate_before_blockô   s    
z&ParallelStatNode.evaluate_before_blockc             C   s&   | j dk	r"| d|  || j ¡ ¡ dS )zS
        Write self.num_threads if set as the num_threads OpenMP directive
        Nz num_threads(%s))rO  rÝ  rf  )r~   rU   r&   r&   r'   Úput_num_threads !  s    
z ParallelStatNode.put_num_threadsc             C   s6   g | _ x*t| jƒD ]}|js"|jr|  ||¡ qW 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`  rj  Zfrom_closurerá  r^  )r~   rU   rÇ   r&   r&   r'   Údeclare_closure_privates!  s    z)ParallelStatNode.declare_closure_privatesc             C   s@   x:| j D ]0\}}| d||jf ¡ |j |j¡ ||_qW 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.
        z%s = %s;N)r_  rO   r  r¦  r­  )r~   rU   rÇ   rf  r&   r&   r'   Úrelease_closure_privates!  s    z)ParallelStatNode.release_closure_privatesr&   c       
      C   sÜ   | j }d| _ | jrØ|j ¡  | _}g g  }}x6t|ƒD ]*\}}|jsJ|jrV| |¡ q6| |¡ q6W |r|| 	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)z, z 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~   rU   Zexclude_tempsrš   r»   rQ  Zfirstprivatesr®  r/   Zshared_varsr&   r&   r'   Úprivatize_temps !  s&    
z ParallelStatNode.privatize_tempsc             C   sh   | j rd| jsd| d¡ xLt| jƒD ]>\}}|jr@|j|dd q"|jr"| ||¡ | d| ¡ q"W d S )Nz/* Clean up any temporaries */F)rÊ  z
%s = NULL;)	r[  Úis_nested_prangerO   r`  r»   rŠ  r  r;   r	  )r~   rU   r®  r/   r&   r&   r'   Úcleanup_temps>!  s    
zParallelStatNode.cleanup_tempsc             C   sT   |  ¡ | _| ¡ | _|j| _|jdd|_| ¡  | ¡ | _	| ¡ | _
|  |¡ dS )a¥  
        Sets up a block that surrounds the parallel block to determine
        how the parallel section was exited. Any kind of return is
        trapped (break, continue, return, exceptions). This is the idea:

        {
            int why = 0;

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

            new_return_label:
                why = 3;
                goto end_parallel;

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

            if (why == 3)
                goto old_return_label;
        }
        Úreturn)r:   N)r·  r¹  r¶  r½  r  r   rÖ  r/  rä  Ú%begin_of_parallel_control_block_pointrd  Ú"undef_builtin_expect_apple_gcc_bug)r~   rU   r&   r&   r'   Ú!setup_parallel_control_flow_blockI!  s    



z2ParallelStatNode.setup_parallel_control_flow_blockc             C   s   |  ¡ | _dS )aœ  
        Each OpenMP thread in a parallel section that contains a with gil block
        must have the thread-state initialized. The call to
        PyGILState_Release() then deallocates our threadstate. If we wouldn't
        do this, each with gil block would allocate and deallocate one, thereby
        losing exception information before it can be saved before leaving the
        parallel section.
        N)rä  Úbegin_of_parallel_block)r~   rU   r&   r&   r'   Úbegin_parallel_blockn!  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.
        Nz#ifdef _OPENMPT)ré  ZPy_BEGIN_ALLOW_THREADSz#endif /* _OPENMP */ZPy_END_ALLOW_THREADSz#elsez{
z#ifndef _OPENMPz}
)rx  rm  rO   rè  Zput_safers  r  )r~   rU   Z
begin_codeZend_coder&   r&   r'   Úend_parallel_blocky!  s&    











z#ParallelStatNode.end_parallel_blockc       	      C   s^  |  ¡ }|  ¡ }d| _d| _d| _g | _| ¡ }x.|D ]&}| |¡r6| jpR||jk| _d| _q6W | jrp| |¡ x”t	|ƒD ]ˆ\}}| |¡sŽqz||jk}| 
|¡ |rª|sÜ||jkrÄd| _|  |¡ | dtj|d f ¡ | jrø| jrø|sø| |¡ qz| |¡ qzW | jrZ| jr2| jr2| 
|¡ |  |¡ | 
|¡ |rZ| jrZ| 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   z#pragma omp flush(%s)N)rÖ  Úany_label_usedrk  rm  Úparallel_private_tempsr  r¹  r  r  r  r  r  Úfetch_parallel_exceptionrO   r	   rl  rT  Úsave_parallel_varsr’  )	r~   rU   Úshould_flushZsave_lastprivates_labelZdont_return_labelZ
all_labelsrÿ  r(  Zis_continue_labelr&   r&   r'   Útrap_parallel_exitš!  sF    











z#ParallelStatNode.trap_parallel_exitc             C   sì   d| j  }| d| ¡ t j d7  _ | ¡  | j}d}x¦t| j ¡ ƒD ]”\}\}}|rH|jj	rbqH|j 
¡ }d| }	|j}
|d7 }|j ¡ }|r¢d|j |¡ }nd}| d||	|f ¡ | d	|	|
f ¡ | j |	|
f¡ qHW | ¡  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%dz = r«   z%s %s%s;z%s = %s;N)Úcritical_section_counterr’  rN  r/  ru  r`  rQ  rc   r/   r;   rC  r  ra  rJ  rO   r|  r  r0  )r~   rU   Úsection_namerš   Z
temp_countrÇ   r_  r]  Z	type_declÚ
temp_cnameÚprivate_cnamera  r  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
        T)ré  z#pragma omp flush(%s)z
if (!%s) {z'__Pyx_ErrFetchWithState(&%s, &%s, &%s);z%s = %s; %s = %s; %s = %s;rÉ  N)r/  rè  r’  r	   Úparallel_exc_typerO   ro  r   rB  Úparallel_pos_inforp  r¦  Zuses_error_indicatorrÌ  rª  r  r0  )r~   rU   rp  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 exceptionT)ré  z&__Pyx_ErrRestoreWithState(%s, %s, %s);z%s = %s; %s = %s; %s = %s;N)r/  rè  rN  r	   r…  rO   ro  r   rB  rp  r†  rÌ  r  r0  )r~   rU   rp  r&   r&   r'   Úrestore_parallel_exception6"  s    z+ParallelStatNode.restore_parallel_exceptionc             C   s   |  | j| j| jf ¡ dS )z›
        Restore all old labels. Call this before the 'else' clause to for
        loops and always before ending the parallel control flow block.
        N)r  r¹  r   r½  )r~   rU   r&   r&   r'   Úrestore_labelsC"  s    zParallelStatNode.restore_labelsc       	      C   s¾  | j }d| _ d| _| jdk	r4| j |¡ | j |¡ | jrŽ| d| j ¡ | d| j ¡ | dt	j
 ¡ | d¡ | dt	j ¡ | d¡ |rš| j}n| j}|r¨| dt	j ¡ | d	t	j ¡ | dt	j ¡ x$| jD ]\}}| d
||f ¡ qÞW | dt	j ¡ |r(| d¡ | |j¡ |rD| 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;z	if (%s) {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;z%s = 0;z%s = %s;zswitch (%s) {z    case 1: z    case 2: z    case 3: z    case 4:)ru  rd  rO  r  rP  rm  rO   r†  ro  r	   r…  rl  r{  rk  r|  rÝ  r  r  r‹  r  rÂ   rl  r
  r‡  r  r0  Ú"redef_builtin_expect_apple_gcc_bug)	r~   rU   Úbreak_Ú	continue_Úreturn_rš   r{  rƒ  r„  r&   r&   r'   Úend_parallel_control_flow_blockK"  sZ    







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)rZ  Zundef_builtin_expectÚredef_condition)r~   rU   r&   r&   r'   rv   "  s    z3ParallelStatNode.undef_builtin_expect_apple_gcc_bugc             C   s   | j s| | j¡ d S )N)rZ  Zredef_builtin_expectrŽ  )r~   rU   r&   r&   r'   r‰  §"  s    z3ParallelStatNode.redef_builtin_expect_apple_gcc_bug)N)r&   )F)FFF)5rK   rk   rl   rx   r‰   r“   rT  rr  rm  rO  rS  r	   r…  Zparallel_exc_valueZparallel_exc_tbro  Zparallel_filenameZparallel_linenoZparallel_clinenor†  r$  r"  r#  rp  r  r€   r   rp   rY  r\  r^  rc  rf  rg  rh  ri  rq  rs  rw  ry  rz  r€  r~  r}  r‡  rˆ  r  Zbuggy_platform_macro_conditionZhave_expect_conditionrŽ  rv  r‰  rm   r&   r&   )rJ   r'   rN  ß  sZ   &G

%!
C+.	
OrN  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
    rO  Nc                s&   t t| ƒ |¡ | jr"t| jdƒ d S )Nz=cython.parallel.parallel() does not take positional arguments)rd   r  r   rR   r   r%   )r~   rA   )rJ   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 )
Nz#ifdef _OPENMPz#pragma omp parallel c             S   s   g | ]}|j js|j‘qS r&   )r/   r;   r  )r†   rk  r&   r&   r'   rˆ   Ã"  s    zAParallelWithBlockNode.generate_execution_code.<locals>.<listcomp>zprivate(%s)z, r«   z#endif /* _OPENMP */)rŠ  r‹  rŒ  )rh  rw  rO   rÝ  rQ  r¡   r`  rä  rj  rg  r/  ry  rc  r¦  Ústart_collecting_tempsr“   rÄ   r€  rq  rz  r0  r¹  r  r‹  r  rˆ  r  ri  )r~   rU   rQ  r‹  rŠ  rŒ  r&   r&   r'   rÄ   »"  s8    














z-ParallelWithBlockNode.generate_execution_code)	rK   rk   rl   rx   rV  rO  r   rÄ   rm   r&   r&   )rJ   r'   r  ¬"  s
   r  c                   s”   e Zd ZdZddddddgZd Z Z ZZd Z	 Z
Zd	ZdZdZd
dddgZ‡ fdd„Z‡ fdd„Z‡ fdd„Zdd„ Zdd„ Zdd„ Z‡  ZS )ÚParallelRangeNodezÌ
    This node represents a 'for i in cython.parallel.prange():' construct.

    target       NameNode       the target iteration variable
    else_clause  Node or None   the else clause of this loop
    r“   rQ  r£  rR   rO  rS  NTÚscheduler  c                s"   t t| ƒj|f|Ž t|ƒ| _d S )N)rd   r‘  r€   rB  rÒ  )r~   r%   rS   )rJ   r&   r'   r€   ø"  s    zParallelRangeNode.__init__c                sÜ   t t| ƒ |¡ | j |¡ | jd k	r2| j |¡ | jrFt| jƒdkrVt| j	dƒ d S t| jƒdkrp| j\| _
n0t| jƒdkrŽ| j\| _| _
n| j\| _| _
| _t| jdƒrº| j d¡| _| jdk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)rd   r‘  r   rQ  r  r£  rR   rH   r   r%   rU  rW   rß  rD  r’  r“  )r~   rA   )rJ   r&   r'   r   ý"  s     

z&ParallelRangeNode.analyse_declarationsc                sT  |j }| j rd|_ | jd kr,t| jdƒ | S | j |¡| _| jjjsn| jjjsdt| jjd| jj ƒ tj	| _
n
| jj| _
d| _| j| j| jf}xrt|| jƒD ]b\}}|d k	rœ| |¡ |jjsÐt|jd| ƒ qœ|jsì| |¡}t| ||ƒ t | j
|j¡| _
qœW | jd k	r| j |¡| _t| jdƒr@| jjd f| j| jj< tt| ƒ |¡}|jrÚ|jspt|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$rP|}x|j"r$|j"j#r$|j"}qW |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)rW   rU  rß  z%s argument must be numericrÇ   z$Must provide schedule with chunksizer•  z,Chunksize not valid for the schedule runtimer   zChunksize must not be negative))r  rQ  r   r%   rq   r/   rb  r;   r
   rÅ  Ú
index_typer>  rW   rU  rß  rB  ro   r¸   r\  rŒ   râ  r£  rp   rD  rj  rÇ   rd   r‘  rS  r’  rø   rO  r"  r=   rZ  rT  rr  r}   rQ  rR  rn  )r~   rA   r-  Ústart_stop_steprT   r:   rZ  )rJ   r&   r'   rp   #  sn    







z%ParallelRangeNode.analyse_expressionsc             C   sT   d}| j | j| j| jf}x6t||ƒD ](\}}|d k	r$|jjr$t|jd| ƒ q$W d S )N)rW   rU  rß  rQ  z6%s may not be a Python object as we don't have the GIL)	rW   rU  rß  rQ  rB  r/   r;   r   r%   )r~   rA   r>  Znodesr:   rT   r&   r&   r'   r½   i#  s    zParallelRangeNode.nogil_checkc             C   sÆ  |   |¡ | jjj}|| jj ¡ dœ}| j| j| jf}d}xTt	|| j
|ƒD ]B\}}}|dkrb|}	n"|jrr| ¡ }	n| |¡ | ¡ }	|	||< qJW |j | jd¡|d< |j | jd¡|d< | d| ¡ |  |¡ | d| ¡ | d	| ¡ | ¡  |  ||¡ | ¡  |  |¡ | jrX| jr2| d
tj ¡ | ¡  | d¡ | j |¡ | ¡  |  |¡ x4|| jf D ]$}
|
dk	rp|
  |¡ |
 !|¡ qpW |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
        )rQ  rþ  )rl  rl  ræ  NFr(  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)zif (%s < 2)z
/* else */)$rh  rQ  rÇ   r  r/   rC  rW   rU  rß  rB  r>  r¸   rù   rI  r   r¦  r§  r–  rO   rw  r/  Úgenerate_loopr0  rˆ  r£  rk  rÝ  r	   rl  rÄ   r  rS  r  rP  r­  ri  )r~   rU   Ztarget_index_cnameÚfmt_dictr—  ÚdefaultsrT   r:   rÛ   r   r®  r&   r&   r'   rÄ   q#  sN    (









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¡ xÄt	| j
 ¡ ƒD ]²\}\}}|r|dkr|| jjkr|jjröt| jdƒ n| d	||jf ¡ q¶|| jjkr<| d
|j ¡ | d|j ¡ q¶|jjs¶|rPd}nd}| d||jf ¡ q¶W | jr¨| jrd|  || j¡ }nd}| d| j|f ¡ |  |¡ | d¡ | d¡ | d| ¡ | ¡  | ¡ }	| ¡  | d| ¡ | j|| jjd | jr&| j s&|j ¡  | j |¡ | j|dd | jrZ| j sZ|  |¡ | jrr|	 dtj  ¡ | !¡  | !¡  | jrœ|  "|¡ | !¡  d S )Nz#if 0z#ifdef _OPENMPz#pragma omp forz#pragma omp parallelr«   z#endif /* _OPENMP */z+*-&^|z#Python objects cannot be reductionsz reduction(%s:%s)z firstprivate(%s)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);)rb  T)r  zif (%s < 2))#rr  rO   r[  rÝ  rä  rj  rZ  r/  ry  r`  rQ  rc   rQ  rÇ   r/   r;   r   r%   r  r’  rS  rf  rg  rc  r¦  r  r“   rÄ   r€  rq  rk  r	   rl  r0  rz  )
r~   rU   r™  Zreduction_codepointrÇ   r_  r]  r[  rS  Zguard_around_body_codepointr&   r&   r'   r˜  ä#  sx    
















zParallelRangeNode.generate_loop)rK   rk   rl   rx   r‰   r“   rQ  r£  rR   rW   rU  rß  rT  r  r’  rV  r€   r   rp   r½   rÄ   r˜  rm   r&   r&   )rJ   r'   r‘  â"  s   
Usr‘  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
    rT   c             C   sD  | j  |¡ | j }t|tƒr(|jjd }t|tƒ| _t|tt	fƒ}|j
}| jr„| j|_| j|_d|_|jr‚d|jkr‚|  |j¡|_n¼|rš| j |_|j_n¦|j}| j|_| jd |j_tj| j |j_| jd |j_|jj|jj_|jj|j_| jd |_xD|j ¡ D ]6\}}|jr$|  |j¡|_|jr|  |j¡|_qW d S )Nr   Tr"  Ú_objÚ_typer|  )rT   r   rI   r¿   r“   rË   r±  Úis_functionr‘  r£  rÇ   r  r`  r7  rš  r4  r/   r0  r$  r	   Ztypeobj_prefixr%  ró  r  rM  r™  rÆ   rc   )r~   rA   rT   Zis_struct_or_enumrk  r0  r:   rÇ   r&   r&   r'   r   Y$  s8    
z'CnameDecoratorNode.analyse_declarationsc             C   s$   d|kr|  d¡d }d| j|f S )Nr"  r®   z%s_%s)r(  r  )r~   r  r&   r&   r'   r4  $  s    zCnameDecoratorNode.manglec             C   s   | j  |¡| _ | S )N)rT   rp   )r~   rA   r&   r&   r'   rp   …$  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_protoFT)rÄ  rÅ  r   )Ú
ModuleNode)Z
definitionN)rž  r  rÂ   rI   rT   rL  rÜ  r«   rŸ  rÇ   r  r`  Zgenerate_cfunction_declarationrÅ   rÃ   )r~   rA   rU   Zh_coderŸ  rÇ   r  r&   r&   r'   rÃ   ‰$  s     
z0CnameDecoratorNode.generate_function_definitionsc             C   s   | j  |¡ d S )N)rT   rÄ   )r~   rU   r&   r&   r'   rÄ   ¢$  s    z*CnameDecoratorNode.generate_execution_codeN)
rK   rk   rl   rx   r‰   r   r4  rp   rÃ   rÄ   r&   r&   r&   r'   r›  I$  s   &r›  aC  
/* Test for GCC > 2.95 */
#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
  #define likely(x)   __builtin_expect(!!(x), 1)
  #define unlikely(x) __builtin_expect(!!(x), 0)
#else /* !__GNUC__ or GCC < 2.95 */
  #define likely(x)   (x)
  #define unlikely(x) (x)
#endif /* __GNUC__ */
z1
#define likely(x)   (x)
#define unlikely(x) (x)
ZPrintz
Printing.cZPrintOner
  zExceptions.cZRaiseExceptionZGetExceptionZSwapExceptionZSaveResetExceptionZAddTracebackzR
static PyObject *__Pyx_GetExceptionTuple(PyThreadState *__pyx_tstate); /*proto*/
a1  
static PyObject *__Pyx_GetExceptionTuple(CYTHON_UNUSED PyThreadState *__pyx_tstate) {
    PyObject *type = NULL, *value = NULL, *tb = NULL;
    if (__Pyx_GetException(&type, &value, &tb) == 0) {
        PyObject* exc_info = PyTuple_New(3);
        if (exc_info) {
            Py_INCREF(type);
            Py_INCREF(value);
            Py_INCREF(tb);
            PyTuple_SET_ITEM(exc_info, 0, type);
            PyTuple_SET_ITEM(exc_info, 1, value);
            PyTuple_SET_ITEM(exc_info, 2, tb);
            return exc_info;
        }
    }
    return NULL;
}
)ré  ÚimplÚrequires)N)¥Ú
__future__r   rC  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   ra   r   ZStringEncodingr   r   r   r   ZPythranr   r    r!   ZUtilsr#   rx  r1   r   r2   r(   r.   rE   r\   r/   r]   rn   rz   r{   r¿   r’   rÊ   rÐ   rÑ   r×   rÚ   ré   rì   rí   rÿ   r:  r=  rZ  r?   r[  rd  rn  rE  r{  r}  r  r‚  rÒ   r‘  r–  r£  r¯  r°  r±  rŸ  rp  rK  rL  r€  râ  rí  rï  rð  rñ  rP  r  r	  r  r<  r=  r?  r  rH  rL  rn  rI  rw  r~  r…  r†  rB  r‰  rŠ  rŒ  rV  r“  r  r   r¡  r«  r®  r±  rµ  r¶  rº  rÏ  r×  rØ  rÕ  rÔ  rÖ  rí  ró  rõ  r  r  r%  r&  r  r1  r2  r<  Zutility_code_for_importsr6  r?  rH  rM  rN  r  r‘  r›  Zgcc_branch_hintsZbranch_prediction_macrosrÔ  r  rƒ  r
  rœ  r  r!  rý  Ztraceback_utility_codeZ get_exception_tuple_utility_coder&   r&   r&   r'   Ú<module>   sz  


$
/ ,*%#, Bt	^!Q'm-X1!                  08 9r N   @  2f/GC)8
sh=C)$/<\<
f
 pg! + '  "	H	+O\     R6  ic