3
hd0	             8   @   s  d dl mZ d dlZejeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeejd$ d dlZd dlZd dlZd dl	Z
d dlZddlmZmZmZmZmZmZmZmZ ddlmZmZ ddlmZ ddlmZ dd	lmZ dd
lmZmZ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&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z3m4Z4 ddlm%Z% ddlm5Z5 ddlm6Z6 ddl7m8Z8 ddlm9Z9 ddl:m;Z; ddl<m=Z=m>Z> ddl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZN ddlmOZO yd dlPmQZQ W n" eRk
rJ   eSZQeTeSfZUY n
X eTeVfZUejWd  dkrndZXeYZZndZXeYe[fZZG dd deZ\e\ Z]e Z^e+e,fde+e-fd e+ej_fd!e+ej`fd!e+ejafd!e+ejbfd!e-e+fd"e-e,fd#e-e/fd$e-ejcfd%e-ejdfd%e/e-fd&e,e+fd'e,e-fd(e,ej_fd)e,ej`fd)e,ejafd)e,ejbfd)e,ejcfd*e,ejdfd*ej_e+fd+ej`e+fd+ejae+fd+ejbe+fd+iZed,d- Zfd.d/ Zgd0d1 Zhdd2d3Zid4d5 Zjd6d7 Zkd8d9 Zld:d; Zmd<d= Znd>d? ZoG d@dA dAeZpG dBdC dCepZqG dDdE dEeqZrG dFdG dGerZsG dHdI dIerZtG dJdK dKeqZuG dLdM dMeuZvG dNdO dOeuZwG dPdQ dQeuZxG dRdS dSeuZyG dTdU dUeuZzdVdW Z{G dXdY dYeuZ|G dZd[ d[euZ}G d\d] d]erZ~G d^d_ d_e~ZG d`da daeqZG dbdc dceqZG ddde deeqZG dfdg dgepZG dhdi diepZG djdk dkepZG dldm dmeZG dndo doepZG dpdq dqeqZG drds dseZG dtdu dueqZG dvdw dwepZG dxdy dyeqZG dzd{ d{epZG d|d} d}eZG d~d depZG dd depZG dd depZG dd deqZG dd deqZG dd depZG dd deZG dd deZG dd deZG dd deZG dd depZG dd deZG dd deZG dd depZG dd depZG dd deZG dd depZG dd deZG dd depZG dd deZG dd deZG dd depZG dd deZG dd deZG dd deZG dd depZG dd depZG dd depZG dd depZG dd depZG dd deZG dd deZG dd deZG dd deZG ddÄ deZG ddń depZG ddǄ depZG ddɄ depZG dd˄ depZG dd̈́ depZG ddτ depZG ddф deZG ddӄ depeZG ddՄ depZG ddׄ depZG ddل depeZG ddۄ depZG dd݄ depZG dd߄ depeZG dd deZG dd depZG dd depZG dd depZG dd deZG dd deZG dd deZG dd deƃZG dd depZG dd deȃZG dd deɃZG dd deɃZG dd de˃ZG dd deqZG dd deZG dd deZG d d deqZАdd ZejejejejՐdZG dd depZG dd de׃ZG d	d
 d
e׃ZG dd de׃ZG dd de׃ZG dd de׃ZG dd de܃ZG dd de܃Zސdd ZG dd de܃ZeeeېdZdd ZG dd depZdZdZd Zd!Zd"ZG d#d$ d$epZG d%d& d&epZG d'd( d(eZG d)d* d*eZG d+d, d,epZG d-d. d.epZy
ejZW n" ek
r   d/d0 ZY nX ejejejejejejejejejejejejejejej ejejejejejed1d2 d3d2 d4Zd5d6 ZG d7d8 d8epZG d9d: d:eZ	d;d< Z
G d=d> d>eZG d?d@ d@eZG dAdB dBeZG dCdD dDeZG dEdF dFeZG dGdH dHeZG dIdJ dJeZejdKjZedLdMdNdOdPdQdRdSdTdUdVdWdXdYdZhZG d[d\ d\eZG d]d^ d^eZG d_d` d`epZG dadb dbepZG dcdd ddepZdedfdgdhdhdidjdgdhdk	ZG dldm dmeZG dndo doepeZG dpdq dqeeZeeeeeeeeeeeeeeedrZ ddsdtZ!G dudv dvepZ"G dwdx dxe"Z#G dydz dze"Z$G d{d| d|e"Z%G d}d~ d~e"Z&G dd de"Z'G dd de'Z(G dd de"Z)G dd de"Z*G dd de"Z+dd Z,G dd de"Z-G dd de"Z.G dd de"Z/G dd de"Z0G dd de/Z1G dd depZ2G dd depZ3G dd depZ4G dd depZ5dS (      )absolute_importN)$errorwarningZ	warn_onceInternalErrorCompileErrorUtilityCodeTempitaUtilityCodeStringEncodingoperatorlocal_errorsreport_errorNamingNodes
PyrexTypespy_object_type	list_type
tuple_typeset_type	dict_typeunicode_typestr_type
bytes_type	type_typeBuiltinSymtabUtilsfind_coercion_errordebug_disposal_codeZdebug_temp_allocdebug_coercionbytearray_type
slice_typememoryview_typebuiltin_sequence_types_py_int_types
IS_PYTHON3   )r   r   r   r   r   r   CannotSpecializeperformance_hint)r   r   )r	   )r   )r   )Nodeutility_code_for_importsSingleAssignmentNode)r   )r   typecast
error_typeunspecified_type)	TypeSlots)r   r   r   r   r   r   r   r   r   basestring_typer    	long_typesequence_typesr!   )r   )r      )r   )AnnotationItem)Future)print_call_chain)r   r   )
to_pythranis_pythran_supported_type#is_pythran_supported_operation_typeis_pythran_exprpythran_func_typepythran_binop_typepythran_unaryop_typehas_np_pythranpythran_indexing_codepythran_indexing_type!is_pythran_supported_node_or_nonepythran_typepythran_is_numpy_func_supportedpythran_get_func_include_filepythran_functor)PythranExpr)
basestring   TFc                   s(   e Zd ZdZ fddZdd Z  ZS )NotConstantNc                s"   t jd krtt | j| t _t jS )N)rH   _objsuper__new__)cls)	__class__ k/var/www/html/CrowdFlow/Picklecon/ble_analysis_env/lib/python3.6/site-packages/Cython/Compiler/ExprNodes.pyrK   O   s    
zNotConstant.__new__c             C   s   dS )Nz<NOT CONSTANT>rN   )selfrN   rN   rO   __repr__U   s    zNotConstant.__repr__)__name__
__module____qualname__rI   rK   rQ   __classcell__rN   rN   )rM   rO   rH   L   s   rH   zgCannot convert Unicode string to 'str' implicitly. This is not portable and requires explicit encoding.zGCannot convert Unicode string to 'bytes' implicitly, encoding required.z5Unicode objects only support coercion to Py_UNICODE*.zFCannot convert 'bytes' object to unicode implicitly, decoding requiredzMCannot convert 'bytes' object to str implicitly. This is not portable to Py3.zTCannot convert 'bytes' object to basestring implicitly. This is not portable to Py3.z<Cannot convert 'bytes' object to Py_UNICODE*, use 'unicode'.zMCannot convert 'basestring' object to bytes implicitly. This is not portable.zZstr objects do not support coercion to unicode, use a unicode string literal instead (u'')zACannot convert 'str' to 'bytes' implicitly. This is not portable.z@'str' objects do not support coercion to C types (use 'bytes'?).zB'str' objects do not support coercion to C types (use 'unicode'?).z?Cannot convert 'char*' to unicode implicitly, decoding requiredc                s~   t j }|d kr|S |jd rvt fddtjtjtjtjfD rv d j	rT|S |jd d	krf|S d d j
 S n|S d S )
Nc_string_encodingc             3   s   | ]}| kV  qd S )NrN   ).0t)
type_tuplerN   rO   	<genexpr>   s    z&find_coercion_error.<locals>.<genexpr>r%   asciidefaultz_'%s' objects do not support coercion to C types with non-ascii or non-default c_string_encodingr   )r[   r\   )coercion_error_dictget
directivesanyr   c_char_ptr_typec_uchar_ptr_typec_const_char_ptr_typec_const_uchar_ptr_typeis_pyobjectname)rY   r\   enverrrN   )rY   rO   r      s    


r   c             C   s   t tttdj| jd S )N)bytes	bytearraystrunicodeZc_string_type)r   r   r   r   r^   r_   )rg   rN   rN   rO   default_str_type   s
    rm   c              G   sR   xL| D ]D}|dkst |jt r0t |jt r0q|jdk rt|jddd qW dS )z
    Raise a warning on nodes that are known to have negative numeric values.
    Used to find (potential) bugs inside of "wraparound=False" sections.
    Nr   zfthe result of using negative indices inside of code sections marked as 'wraparound=False' is undefinedr%   )level)
isinstanceconstant_resultr#   floatr   pos)nodesnoderN   rN   rO   check_negative_indices   s    

ru   c                s   |j sZ|d kr|j }|tkrZ|jrZt|jdkrZy|jd j}W n tk
rX   Y nX |d k	r|j r|d k	r|j ry|j|j	 }W n t
ttfk
r   Y nX |j S  fdd|jD }t|dkr|j S d S )Nr%   r   c                s   h | ]}|j  qS rN   )
infer_type)rW   item)rg   rN   rO   	<setcomp>   s    z+infer_sequence_item_type.<locals>.<setcomp>)is_sequence_constructorrv   r   cf_statelenrhsAttributeErrorhas_constant_resultargsrp   
ValueError	TypeError
IndexErrorpop)rg   Zseq_node
index_nodeseq_typerw   
item_typesrN   )rg   rO   infer_sequence_item_type   s(    

r   c             C   s&   dd |D }d|krdS | t |fS )a  
    Recursively generate a deduplication key from a sequence of values.
    Includes Cython node types to work around the fact that (1, 2.0) == (1.0, 2), for example.

    @param outer_type: The type of the outer container.
    @param item_nodes: A sequence of constant nodes that will be traversed recursively.
    @return: A tuple that can be used as a dict key for deduplication.
    c             S   s   g | ]}|d krt d td fn|jrDt|j|jr6|jnd g|j nf|jrbt|j|j|j	|j
fnH|j r|j|j|jt krt|jnd fnt|tr|j|j|jdfnd qS )NIdentifierStringNode)r   typery   make_dedup_key
is_literalmult_factorr   is_slicestartstopstepr~   rp   ro   r   valueunicode_value)rW   rt   rN   rN   rO   
<listcomp>   s   z"make_dedup_key.<locals>.<listcomp>N)tuple)Z
outer_typeZ
item_nodesZ	item_keysrN   rN   rO   r      s
    
r   c             C   sZ   | d krdS | j tjkr&| jdkr&dS | j jrFd| jj| jjf dfS d| jj dfS d S )	N__Pyx_CppExn2PyErr();F*Tzttry { throw; } catch(const std::exception& exn) {PyErr_SetString(%s, exn.what());} catch(...) { PyErr_SetNone(%s); }zc%s(); if (!PyErr_Occurred())PyErr_SetString(PyExc_RuntimeError, "Error converting c++ exception.");)r   F)r   T)r   r   c_char_typer   re   entrycname)exception_valuerN   rN   rO   get_exception_handler   s    

r   c             C   sF   |rB|r0| j jtjdd | j| jd| n| j| jd| d S )NErrOccurredWithGILzExceptions.cz__Pyx_ErrOccurredWithGIL()zPyErr_Occurred())globalstateuse_utility_coder   load_cachedputlnerror_goto_if)codecheck_py_exceptionrr   nogilrN   rN   rO   maybe_check_py_error   s    r   c             C   s   t |\}}| jd | jd|  |r:| j| j|| t| ||| | jd |rb| jdd | j| |rx| j  | j| j| | jd d S )Nztry {z%sz} catch(...) {T)declare_gilstate})r   r   error_goto_if_nullr   put_ensure_gilput_release_ensured_gil
error_goto)r   rr   Zinside	py_resultr   r   Zraise_py_exceptionr   rN   rN   rO   translate_cpp_exception  s    


r   c             C   sH   | j dkst| jd krdS | jjr(dS t| jtrD| jjdkrDdS dS )N+TFr   )exception_checkAssertionErrorr   is_namero   CharNoder   )rt   rN   rN   rO   needs_cpp_exception_conversion  s    
r   c             C   s  t |\}}	t |\}
}| jd | j|jd|  t| |	|| | jd | jd|  t| ||| | jd |r| jdd | j|
 |r| j  | j| j| | jd | jd |r| jdd | j| |r| j  | j| j| | jd d S )Nztry {z__pyx_local_lvalue = %s;z} catch(...) {T)r   r   )r   r   declaration_coder   r   r   r   )r   rr   lhs_typeZlhs_coderhs_codeZlhs_exc_valZassign_exc_valr   Zhandle_lhs_excZlhc_check_py_excZhandle_assignment_excZassignment_check_py_excrN   rN   rO   translate_double_cpp_exception&  s0    






r   c               @   sT  e Zd ZdZdZdZdZdZdZdZ	dZ
dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZeZeeedddddkre e!j"ddZ#ne d	d
 Z#dd Z$dd Z%dd Z&dd Z'dd Z(dd Z)dd Z*dddZ+dd Z,dd Z-ddd Z.d!d" Z/dd#d$Z0d%d& Z1d'd( Z2d)d* Z3d+d, Z4d-d. Z5d/d0 Z6d1d2 Z7d3d4 Z8d5d6 Z9d7d8 Z:d9d: Z;d;d< Z<d=d> Z=d?d@ Z>dAdB Z?dCdD Z@dEdF ZAddHdIZBdJdK ZCdLdM ZDdNdO ZEdPdQ ZFdRdS ZGdTdU ZHdVdW ZIdXdY ZJdZd[ ZKd\d] ZLd^d_ ZMd`da ZNdbdc ZOddde ZPdfdg ZQdhdi ZRdjdk ZSdldm ZTdndo ZUdpdq ZVdrds ZWdtdu ZXdvdw ZYdxdy ZZdzd{ Z[dd|d}Z\dd~dZ]dd Z^dd Z_dd Z`dd Zadd ZbdddZcdd Zddd Zedd Zfdd Zgdd Zhdd ZidddZjdd Zkdd Zldd Zmdd Zndd Zodd Zpdd Zqdd Zrdf fddZsetdd Zudd ZvdS )ExprNodeNTFimplementationrf   cpythonsubexprs)fgetc             C   s   | j S )N)r   )rP   rN   rN   rO   child_attrs  s    zExprNode.child_attrsc             C   s   d S )NrN   )rP   rg   rN   rN   rO   analyse_annotations  s    zExprNode.analyse_annotationsc             C   s"   t |d td| jj|f d S )Nznot implementedz%s.%s not implemented)r5   r   rM   rR   )rP   method_namerN   rN   rO   not_implemented  s    
zExprNode.not_implementedc             C   s   dS )Nr   rN   )rP   rN   rN   rO   	is_lvalue  s    zExprNode.is_lvaluec             C   s   | j  o| jj S )N)r   r   is_memoryviewslice)rP   rN   rN   rO   is_addressable  s    zExprNode.is_addressablec             C   s   | j jo| jS )N)r   re   is_temp)rP   rN   rN   rO   is_ephemeral  s    zExprNode.is_ephemeralc             C   sL   g }xB| j D ]8}t| |}|d k	rt|tkr:|j| q|j| qW |S )N)r   getattrr   listextendappend)rP   rs   rf   rw   rN   rN   rO   subexpr_nodes  s    
zExprNode.subexpr_nodesc             C   s   | j r| jS | j S d S )N)r   	temp_codecalculate_result_code)rP   rN   rN   rO   result  s    zExprNode.resultc             C   s<   |r"| j o| jjo| jj  r"|S d| _dj|r4dnd|S )NTz{}({})Z__PYX_STD_MOVE_IF_SUPPORTEDz	std::move)r   r   is_cpp_classis_referencehas_temp_movedformat)rP   r   optionalrN   rN   rO   _make_move_result_rhs  s    zExprNode._make_move_result_rhsc             C   s   | j | j ddS )NT)r   )r   r   )rP   rN   rN   rO   move_result_rhs  s    zExprNode.move_result_rhsc             C   s6   | j |}|jp|js2|jo | j}| j|| d}|S )N)r   )	result_asr   Zneeds_refcountingZis_rvalue_referencer   r   )rP   r   r   Zrequires_moverN   rN   rO   move_result_rhs_as!  s
    
zExprNode.move_result_rhs_asc             C   s&   t | rt| S |d k	stt| |S )N)r@   r6   r   )rP   type_rN   rN   rO   pythran_result(  s    zExprNode.pythran_resultc             C   s   dS )zZ
        Subtypes may return False here if result temp allocation can be skipped.
        TrN   )rP   rN   rN   rO   is_c_result_required/  s    zExprNode.is_c_result_requiredc             C   s:   | j r&| jjr&|tkr&t|t| j S t|| j | j S )N)r   r   re   r   r+   r   ctype)rP   r   rN   rN   rO   r   5  s    zExprNode.result_asc             C   s
   | j tS )N)r   r   )rP   rN   rN   rO   r   >  s    zExprNode.py_resultc             C   s   | j p
| jS )N)result_ctyper   )rP   rN   rN   rO   r   B  s    zExprNode.ctypec             C   s   d S )NrN   )rP   rN   rN   rO   get_constant_c_result_codeG  s    	z#ExprNode.get_constant_c_result_codec             C   s   d S )NrN   )rP   rN   rN   rO   calculate_constant_resultR  s    
z"ExprNode.calculate_constant_resultc             C   s   | j tk	o| j tk	S )N)rp   constant_value_not_setnot_a_constant)rP   rN   rN   rO   r~   ^  s    
zExprNode.has_constant_resultc             C   s   t | jd d S )NzInvalid compile-time expression)r   rr   )rP   denvrN   rN   rO   compile_time_valueb  s    zExprNode.compile_time_valuec             C   s   t | jd|jj|f  d S )Nz(Error in compile-time expression: %s: %s)r   rr   rM   rR   )rP   erN   rN   rO   compile_time_value_errorf  s    z!ExprNode.compile_time_value_errorc             C   s   t | jd d S )NzCannot assign to or delete this)r   rr   )rP   rg   rN   rN   rO   analyse_target_declarationl  s    z#ExprNode.analyse_target_declarationc             C   s   t | jd d S )Nz=Cannot use anything except a name in an assignment expression)r   rr   )rP   rg   rN   rN   rO   0analyse_assignment_expression_target_declarationo  s    z9ExprNode.analyse_assignment_expression_target_declarationc             C   s   | j |}|j  |S )N)analyse_typescheck_const)rP   rg   rt   rN   rN   rO   analyse_const_expressiont  s    
z!ExprNode.analyse_const_expressionc             C   s
   | j |S )N)r   )rP   rg   rN   rN   rO   analyse_expressions}  s    zExprNode.analyse_expressionsc             C   s
   | j |S )N)analyse_target_types)rP   rg   r|   rN   rN   rO   analyse_target_expression  s    z"ExprNode.analyse_target_expressionc             C   s   | j |}|j|}|S )N)r   coerce_to_boolean)rP   rg   rt   boolrN   rN   rO   analyse_boolean_expression  s    

z#ExprNode.analyse_boolean_expressionc             C   s   | j |}|j|j|S )N)r   r   coerce_to_simple)rP   rg   rt   rN   rN   rO   analyse_temp_boolean_expression  s    
z(ExprNode.analyse_temp_boolean_expressionc                s0   t | dd d k	rf S t fdd| j D f S )Nr   c                s   g | ]}|j  qS rN   )type_dependencies)rW   rt   )rg   rN   rO   r     s    z.ExprNode.type_dependencies.<locals>.<listcomp>)r   sumr   )rP   rg   rN   )rg   rO   r     s    zExprNode.type_dependenciesc             C   s@   t | dd }|d k	r|S t | dd }|d k	r2|jS | jd d S )Nr   r   rv   )r   r   r   )rP   rg   r   r   rN   rN   rO   rv     s    zExprNode.infer_typec             C   s   | j p| jp| jjp| jjS )N)r   r   r   is_arrayis_cfunction)rP   rN   rN   rO   nonlocally_immutable  s    zExprNode.nonlocally_immutabler   c          	   C   s$   t | j| t| jt||tjddS )z
        Return a node that represents the (type) result of an indexing operation,
        e.g. for tuple unpacking or iteration.
        )r   rp   r   )baseindex)	IndexNoderr   IntNoderk   r   c_py_ssize_t_type)rP   r   rN   rN   rO   inferable_item_node  s    
zExprNode.inferable_item_nodec             C   s   d S )NrN   )rP   rg   rN   rN   rO   analyse_as_module  s    zExprNode.analyse_as_modulec             C   s   d S )NrN   )rP   rg   rN   rN   rO   analyse_as_type  s    zExprNode.analyse_as_typec             C   sV   | j |}|r<|jr<|jr<y|j|jS  tk
r:   Y nX |rR|jrRt| jd |S )NzType is not specific)r   is_fusedfused_to_specific
specializeKeyErrorr   rr   )rP   rg   r   rN   rN   rO   analyse_as_specialized_type  s    

z$ExprNode.analyse_as_specialized_typec             C   s   d S )NrN   )rP   rg   rN   rN   rO   analyse_as_extension_type  s    z"ExprNode.analyse_as_extension_typec             C   s   | j d d S )Nr   )r   )rP   rg   rN   rN   rO   r     s    zExprNode.analyse_typesc             C   s
   | j |S )N)r   )rP   rg   rN   rN   rO   r     s    zExprNode.analyse_target_typesc             C   s   | j r| j jr| j  d S )N)r   re   	gil_error)rP   rg   rN   rN   rO   nogil_check  s    zExprNode.nogil_checkc             C   s   |j r| jjrt| jd d S )Nz3Assignment of Python object not allowed without gil)r   r   re   r   rr   )rP   rg   rN   rN   rO   gil_assignment_check  s    zExprNode.gil_assignment_checkc             C   s   | j   dS )NF)	not_const)rP   rN   rN   rO   r     s    zExprNode.check_constc             C   s   t | jd d S )Nz$Not allowed in a constant expression)r   rr   )rP   rN   rN   rO   r    s    zExprNode.not_constc             C   s   | j   dS )NF)addr_not_const)rP   rN   rN   rO   check_const_addr  s    zExprNode.check_const_addrc             C   s   t | jd d S )NzAddress is not constant)r   rr   )rP   rN   rN   rO   r    s    zExprNode.addr_not_constc             C   s   | j S )N)r   )rP   rN   rN   rO   result_in_temp  s    zExprNode.result_in_tempc             C   s   | j  S )N)r   )rP   rN   rN   rO   target_code  s    zExprNode.target_codec             C   s   | j d d S )Nr   )r   )rP   rN   rN   rO   r     s    zExprNode.calculate_result_codec             C   st   | j rtd| jj| jf | j}|jsj|jr6tj	}n| j
pH|jpH| j sTd | _ d S |jj|| jd| _ nd | _ d S )Nz'Temp allocated multiple times in %r: %r)
manage_ref)r   RuntimeErrorrM   rR   rr   r   is_voidre   r   r   result_is_usedr   r   	funcstateallocate_tempuse_managed_ref)rP   r   r   rN   rN   rO   allocate_temp_result  s    zExprNode.allocate_temp_resultc             C   s   | j st| jsd S | jr<tjj| jd j f| jdd   nd}| jr`td| j| j	j
|f ntd| j	j
|f |jj| j  | j | _d | _ d S )Nr   r%   z(?)z+temp %s released multiple times in %s at %rz*no temp, but release requested in %s at %r)r   r  rr   ospathbasenameget_descriptionold_tempr  rM   rR   r  release_temp)rP   r   rr   rN   rN   rO   release_temp_result  s    0zExprNode.release_temp_resultc             C   s    | j  s|j| j | j  dS )z|
        Make sure we own a reference to result.
        If the result is in a temp, it is already a new reference.
        N)r
  
put_increfr   r   )rP   r   rN   rN   rO   make_owned_reference/  s    zExprNode.make_owned_referencec             C   s&   | j  s"|j| j | j| j d dS )zJ
        Make sure we own the reference to this memoryview slice.
        )have_gilN)r
  put_incref_memoryviewslicer   r   in_nogil_context)rP   r   rN   rN   rO   make_owned_memoryviewslice7  s    z#ExprNode.make_owned_memoryviewslicec             C   s`   | j | |j| j | jr&| j| | j| | jr\| jjpD| jj r\| j	| | j
| d S )N) generate_subexpr_evaluation_codemark_posrr   r   r  generate_result_coder   	is_stringis_pyunicode_ptrgenerate_subexpr_disposal_codefree_subexpr_temps)rP   r   rN   rN   rO   generate_evaluation_code@  s    



z!ExprNode.generate_evaluation_codec             C   s    x| j  D ]}|j| q
W d S )N)r   r(  )rP   r   rt   rN   rN   rO   r!  Q  s    z)ExprNode.generate_subexpr_evaluation_codec             C   s   | j d d S )Nr#  )r   )rP   r   rN   rN   rO   r#  U  s    zExprNode.generate_result_codec             C   sx   | j r|jjtjdd | jrj| jjs0| jjrD| j	| | j
| | j rt|j| j | j | j d n
| j	| d S )NMoveIfSupportedzCppSupport.cpp)r  )r   r   r   r   r   r   r   r$  r%  r&  r'  r   put_decref_clearr   r  )rP   r   rN   rN   rO   generate_disposal_codeX  s    

zExprNode.generate_disposal_codec             C   s    x| j  D ]}|j| q
W d S )N)r   r+  )rP   r   rt   rN   rN   rO   r&  h  s    z'ExprNode.generate_subexpr_disposal_codec             C   s   | j r| jjs| jjr,| j| | j| nH| jjrH|jd| j   n,| jj	rt|jd| j   |jd| j   | j
r|jjtjdd n
| j| d S )Nz%s = 0;z%s.memview = NULL;z%s.data = NULL;r)  zCppSupport.cpp)r   r   r$  r%  r&  r'  re   r   r   r   r   r   r   r   r   )rP   r   rN   rN   rO   generate_post_assignment_coden  s    
z&ExprNode.generate_post_assignment_codec             C   s   d S )NrN   )rP   r|   r   overloaded_assignmentr   r   rN   rN   rO   generate_assignment_code  s    z!ExprNode.generate_assignment_codec             C   s   d S )NrN   )rP   r   ignore_nonexistingrN   rN   rO   generate_deletion_code  s    zExprNode.generate_deletion_codec             C   s(   | j r| jjs$| j| n
| j| d S )N)r   r   r  r  r'  )rP   r   rN   rN   rO   
free_temps  s    zExprNode.free_tempsc             C   s    x| j  D ]}|j| q
W d S )N)r   r1  )rP   r   subrN   rN   rO   r'    s    zExprNode.free_subexpr_tempsc             C   s   d S )NrN   )rP   rg   r   rN   rN   rO   generate_function_definitions  s    z&ExprNode.generate_function_definitionsc             C   s   |j | j | j | d S )N)put_decref_setr   r   )rP   r   r|   rN   rN   rO   generate_decref_set  s    zExprNode.generate_decref_setc             C   s   |j | j | j | d S )N)Zput_xdecref_setr   r   )rP   r   r|   rN   rN   rO   generate_xdecref_set  s    zExprNode.generate_xdecref_setc             C   s<   |o| j s8|r$| jr$|r$| j| n|j| j | j  d S )N)
cf_is_nullcf_maybe_nullgenerate_xgotref
put_gotrefr   r   )rP   r   handle_nullmaybe_null_extra_checkrN   rN   rO   generate_gotref  s
    

zExprNode.generate_gotrefc             C   s   |j | j | j  d S )N)put_xgotrefr   r   )rP   r   rN   rN   rO   r9    s    zExprNode.generate_xgotrefc             C   s   |j | j | j  d S )N)put_giverefr   r   )rP   r   rN   rN   rO   generate_giveref  s    zExprNode.generate_giverefc             C   s   |j | j | j  d S )N)put_xgiverefr   r   )rP   r   rN   rN   rO   generate_xgiveref  s    zExprNode.generate_xgiverefc             C   s    x| j  D ]}|j| q
W d S )N)r   annotate)rP   r   rt   rN   rN   rO   rC    s    zExprNode.annotatec             C   s  | }| j }| j||r| S |j}|r2|j r2|j}|jr>|j}|jsJ|jr|jr|j r|jr|j	jr|j	}x6|j
 D ]*}|j|rv||_ |j j|_d|j_| S qvW |jrt| jd n|jr|jr| S t| jd t| _ | S | jd k	rt| jd| jd}|j|| |jrddlm} |j jsz|j jr>t|||}n:|j jr^tj||j||}n|jst| jd|f  nl|j jrd|_|j j|| j | j!d	s|j j"j|j"rd
}	|j |f}
nd}	|j j"|j"f}
t| j|	|
  n|jrr|j#rnr|j$d krt%|jj||}nR|j jsT|t&krF|j j'rFt(||}nt)|||d}|j j*|st+|||}nt,|rt-|j r|S t,|j rt-|r|S t)|||d}n|j jr|r|j.rt/| jd|  t0|||}n|j1r||kr|j2|rt3|||}nh|t4j5krJ||krJ|j2| rJt6|||}n6|j |kprt7|j t7|kpr|j2|s| j8| |S )NTzType is not specializedz/Cannot coerce to a type that is not specialized )rf   r   r%   )
MemoryViewz&Cannot convert '%s' to memoryviewslice)	broadcastcopyingz3Memoryview '%s' not conformable to memoryview '%s'.z-Different base types for memoryviews (%s, %s))r   zTCannot pass Python object as C++ data structure reference (%s &), will pass by copy.)9r   check_for_coercion_errorr   ref_base_typeZis_cv_qualifiedZcv_base_typer   r   is_ptr	base_type"get_all_specialized_function_typessame_asr   usedr   rr   Zis_null_ptrr,   coercion_typeNameNode	coerce_tor   rD  rE  re   CoerceToMemViewSliceNoder   CythonArrayNodefrom_carrayis_errorwritable_neededZconforms_tois_memview_broadcastis_memview_copy_assignmentdtypeis_nonerp   NoneNoder   is_intCoerceIntToBytesNodeCoerceToPyTypeNode
subtype_ofPyTypeTestNoder9   r7   r   r   CoerceFromPyTypeNode
is_complexassignable_fromCoerceToComplexNoder   soft_complex_typecoerce_from_soft_complexrk   fail_assignment)rP   dst_typerg   srcZsrc_typeZused_as_reference	signaturert   rE  msgtuprN   rN   rO   rQ    s    











,
zExprNode.coerce_toc             C   s   t | dr| jjnd }| jjr.dj| jj nd}|jrFdj|j nd}|j| j|}|rdd| }t| j	d| j||||f  d S )Nr   z (alias of '{0}')rD  z. z%Cannot assign type '%s'%s to '%s'%s%s)
hasattrr   rf   r   Z
is_typedefr   resolveZassignment_failure_extra_infor   rr   )rP   rh  src_nameZsrc_resolvedZdst_resolvedZextra_diagnosticsrN   rN   rO   rg  E  s    zExprNode.fail_assignmentc             C   sZ   |r| rd}t | j|f||}|d k	rDt| j|| j|d  dS |rV| j| dS dS )Nz)Cannot assign type '%(FROM)s' to '%(TO)s')ZFROMZTOTF)r   r   r   rr   rg  )rP   rh  rg   failr\   messagerN   rN   rO   rH  Q  s    

z!ExprNode.check_for_coercion_errorc             C   s   | j tj|S )N)rQ  r   r   )rP   rg   rN   rN   rO   coerce_to_pyobject]  s    zExprNode.coerce_to_pyobjectc             C   s   | j  r"t| j}t| j||dS | j}|js4|jr8| S |tj	krF| S |j
s^|js^|js^|jrht| |S |jr|jr|jjdrt| jt| j| tjddg dj|S |jrt|jdk}t| j||dS t| jd|  | S d S )N)r   rp   zoperator bool)obj	attribute)functionr   r   z%Type '%s' not acceptable as a boolean)r~   r   rp   BoolNoderr   r   is_enumrU  r   c_bint_typere   r\  rJ  is_floatCoerceToBooleanNoder   scopelookupSimpleCallNodeAttributeNoder	   EncodedStringr   	is_ctupler{   
componentsr   )rP   rg   
bool_valuer   rN   rN   rO   r   `  s.    


zExprNode.coerce_to_booleanc             C   s   | j jr| S | jtj|S d S )N)r   r\  rQ  r   c_long_type)rP   rg   rN   rN   rO   coerce_to_integer  s    zExprNode.coerce_to_integerc             C   s   | j  r| S t| |S d S )N)r
  CoerceToTempNode)rP   rg   rN   rN   rO   coerce_to_temp  s    zExprNode.coerce_to_tempc             C   s   | j  r| S | j|S d S )N)	is_simpler  )rP   rg   rN   rN   rO   r     s    zExprNode.coerce_to_simplec             C   s   | j  S )N)r
  )rP   rN   rN   rO   r    s    zExprNode.is_simplec             C   s2   | j r| j jp| j j rdS | j r.| jd k	S dS )NFT)r   re   r   r~   rp   )rP   rN   rN   rO   may_be_none  s    

zExprNode.may_be_nonec             C   s   d S )NrN   )rP   rN   rN   rO   as_cython_attribute  s    zExprNode.as_cython_attributePyExc_TypeErrorc             C   s   | j  rt| |||S | S d S )N)r  NoneCheckNode)rP   rq  r   format_argsrN   rN   rO   as_none_safe_node  s    zExprNode.as_none_safe_nodec             K   sZ   dj  }xB|D ]:}||krqyt||}W n tk
r>   Y qX |||< qW | |jf|S )zInstantiate this node class from another node, properly
        copying over all attributes that one would forget otherwise.
        z1cf_state cf_maybe_null cf_is_null constant_result)splitr   r}   rr   )rL   rt   kwargs
attributes	attr_namer   rN   rN   rO   	from_node  s    
zExprNode.from_nodec             C   s   dS )z
        Gets the module.path that this node was imported from.

        Many nodes do not have one, or it is ambiguous, in which case
        this function returns a false value.
        NrN   )rP   rN   rN   rO   !get_known_standard_library_import  s    z*ExprNode.get_known_standard_library_import)F)N)N)r   )FNN)F)FT)FN)wrR   rS   rT   r   r   
annotationr   r  r  r  is_numpy_attributeZgenerator_arg_tagry   is_dict_literalis_set_literalis_string_literalis_attributeis_subscriptr   is_buffer_accessis_memview_indexis_memview_slicerW  rX  r   r   	is_target
is_starredr   rp   r   syspropertyr
   
attrgetterr   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   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#  r+  r&  r,  r.  r0  r1  r'  r3  r5  r6  r=  r9  r@  rB  rC  rQ  rg  rH  rr  r   r  r  r   r  r  r  r  classmethodr  r  rN   rN   rN   rO   r   C  s   s



		

	 

 
 	
r   c               @   s    e Zd Zg Zdd Zdd ZdS )AtomicExprNodec             C   s   d S )NrN   )rP   r   rN   rN   rO   r!    s    z/AtomicExprNode.generate_subexpr_evaluation_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r&    s    z-AtomicExprNode.generate_subexpr_disposal_codeN)rR   rS   rT   r   r!  r&  rN   rN   rN   rO   r    s   r  c               @   s@   e Zd ZdZeZdZdd Zdd Zdd Z	d	d
 Z
dd ZdS )PyConstNoder%   Nc             C   s   dS )Nr%   rN   )rP   rN   rN   rO   r    s    zPyConstNode.is_simplec             C   s   dS )NFrN   )rP   rN   rN   rO   r    s    zPyConstNode.may_be_nonec             C   s   | S )NrN   )rP   rg   rN   rN   rO   r     s    zPyConstNode.analyse_typesc             C   s   | j S )N)r   )rP   rN   rN   rO   r     s    z!PyConstNode.calculate_result_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r#    s    z PyConstNode.generate_result_code)rR   rS   rT   r   r   r   r  r  r  r   r   r#  rN   rN   rN   rO   r    s   r  c                   s8   e Zd ZdZdZdZdd Zdd Z fdd	Z  Z	S )
r[  r%   Py_NoneNc             C   s   d S )NrN   )rP   r   rN   rN   rO   r     s    zNoneNode.compile_time_valuec             C   s   dS )NTrN   )rP   rN   rN   rO   r    s    zNoneNode.may_be_nonec                s4   |j p|jp|js"t| jd|  tt| j||S )NzCannot assign None to %s)re   r   rU  r   rr   rJ   r[  rQ  )rP   rh  rg   )rM   rN   rO   rQ    s    zNoneNode.coerce_to)
rR   rS   rT   rZ  r   rp   r   r  rQ  rU   rN   rN   )rM   rO   r[    s   r[  c               @   s   e Zd ZdZeZdd ZdS )EllipsisNodeZPy_Ellipsisc             C   s   t S )N)Ellipsis)rP   r   rN   rN   rO   r     s    zEllipsisNode.compile_time_valueN)rR   rS   rT   r   r  rp   r   rN   rN   rN   rO   r    s   r  c               @   sT   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dd ZdS )	ConstNoder%   Nc             C   s   dS )Nr%   rN   )rP   rN   rN   rO   r    s    zConstNode.is_simplec             C   s   dS )Nr%   rN   )rP   rN   rN   rO   r     s    zConstNode.nonlocally_immutablec             C   s   dS )NFrN   )rP   rN   rN   rO   r    s    zConstNode.may_be_nonec             C   s   | S )NrN   )rP   rg   rN   rN   rO   r     s    zConstNode.analyse_typesc             C   s   dS )NTrN   )rP   rN   rN   rO   r      s    zConstNode.check_constc             C   s   | j  S )N)r   )rP   rN   rN   rO   r   #  s    z$ConstNode.get_constant_c_result_codec             C   s
   t | jS )N)rk   r   )rP   rN   rN   rO   r   &  s    zConstNode.calculate_result_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r#  )  s    zConstNode.generate_result_code)rR   rS   rT   r   r  r  r   r  r   r   r   r   r#  rN   rN   rN   rO   r    s   r  c               @   s2   e Zd ZejZdd Zdd Zdd Zdd Z	d	S )
rv  c             C   s   | j | _d S )N)r   rp   )rP   rN   rN   rO   r   1  s    z"BoolNode.calculate_constant_resultc             C   s   | j S )N)r   )rP   r   rN   rN   rO   r   4  s    zBoolNode.compile_time_valuec             C   s(   | j jr| jrdS dS tt| jS d S )NZPy_TrueZPy_False)r   re   r   rk   int)rP   rN   rN   rO   r   7  s    zBoolNode.calculate_result_codec             C   s   || j kr| S |tkr&| j tjkr&| S |jrL| j jrLt| j| j| j	tjdS |jrr| j jrrt| j| j| j	t
jdS tj| ||S )N)r   rp   r   )r   r   r   Z	bool_typere   r\  rv  rr   r   rp   r   rx  r  rQ  )rP   rh  rg   rN   rN   rO   rQ  =  s    


zBoolNode.coerce_toN)
rR   rS   rT   r   rx  r   r   r   r   rQ  rN   rN   rN   rO   rv  -  s
   rv  c               @   s"   e Zd ZejZdZdZdd ZdS )NullNodeNULLr   c             C   s   | j S )N)r   )rP   rN   rN   rO   r   T  s    z#NullNode.get_constant_c_result_codeN)	rR   rS   rT   r   Zc_null_ptr_typer   r   rp   r   rN   rN   rN   rO   r  O  s   r  c               @   s*   e Zd ZejZdd Zdd Zdd ZdS )r   c             C   s   t | j| _d S )N)ordr   rp   )rP   rN   rN   rO   r   [  s    z"CharNode.calculate_constant_resultc             C   s
   t | jS )N)r  r   )rP   r   rN   rN   rO   r   ^  s    zCharNode.compile_time_valuec             C   s   dt j| j S )Nz'%s')r	   Zescape_charr   )rP   rN   rN   rO   r   a  s    zCharNode.calculate_result_codeN)	rR   rS   rT   r   r   r   r   r   r   rN   rN   rN   rO   r   X  s   r   c               @   s   e Zd ZdZdZdZedd Zedd Zdd Z	d	d
 Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Zdd ZdS )r   rD  Nc             C   s   t jtt j| jS )N)r   strip_py2_long_suffixhexstr_to_numberr   )rP   rN   rN   rO   	hex_valueq  s    zIntNode.hex_valuec             C   s   t tj| jS )N)rk   r   r  r   )rP   rN   rN   rO   base_10_valueu  s    zIntNode.base_10_valuec             K   s&   t j| |f| d|kr"| j | _d S )Nr   )r   __init__find_suitable_type_for_valuer   )rP   rr   kwdsrN   rN   rO   r  y  s    zIntNode.__init__c             C   s   | j tkr,y| j  W n tk
r*   Y nX | jsL| j  sL| jsL| jdkr| jdkrZdp\d}tj	| j |df }| j
rtj|| j
}n>d| j   kodk n  r| j
r| j
jr| j
}qtj}ntj}|S )	NLLr2   r%   r     l        i   l        )rp   r   r   r   is_c_literalr~   unsignedlongnessr   Zmodifiers_and_name_to_typer   widest_numeric_typer\  r  r   )rP   rankZsuitable_typerN   rN   rO   r  ~  s$    

z$IntNode.find_suitable_type_for_valuec          	   C   s   | j |kr| S |jrR| j r>t| jdt| j |t| jdS t| j| j|t	dS |j
r|j rt| j| j| j|d| j| jd}|S |jrt| j| j| jtjd| j| jd}nt| j| j| j| j| jd}tj|||S )Nz%d.0)r   r   rp   T)r   rp   r   r  r  r  F)r   rp   r  r  )r   ry  r~   	FloatNoderr   r  rp   rq   r   r   
is_numericrb  r   r  r  re   r   r   r  rQ  )rP   rh  rg   rt   rN   rN   rO   rQ    s(    
zIntNode.coerce_toc             C   s    t | j| j| jtj| j| jdS )N)r   rp   r   r  r  )r   rr   r   rp   r   rx  r  r  )rP   rg   rN   rN   rO   r     s
    zIntNode.coerce_to_booleanc             C   sV   | j jrHtj| j}|dkr tnt}||}tj|}|j|| j	| _
n
| j | _
d S )N
      l     a$)r   re   r   r  r   r  rk   r  Z
get_py_intr  result_coder   )rP   r   r   	formatterZplain_integer_stringrN   rN   rO   r(    s    
z IntNode.generate_evaluation_codec             C   sv   | j | j }}| j }|p| rj| jjrj|d dkrj|d dkrj| jjtjjkrVd}n| jjtjjkrjd}|| | S )Nr   -r%   0r  L)	r  r  value_as_c_integer_stringr   r\  r  r   Zc_longlong_typer  )rP   r  r  literalrN   rN   rO   r     s    *z"IntNode.get_constant_c_result_codec             C   s   | j }t|dkr|S d}|d dkr6d}|dd  }|d dkr|d }|rv|dkrv|dd  j rvttj|}q|dkrd|dd   }q|d	krtt|dd  d}n(|j r| j r| j r|sd
t| }|| S )Nr2   rD  r   r  r%   r  ZoOxX0123456789ZoOZbBz0x%X)	r   r{   isdigitrk   r   r  r  r  r  )rP   r   Zneg_signZliteral_typerN   rN   rO   r    s&    z!IntNode.value_as_c_integer_stringc             C   s   | j S )N)r  )rP   rN   rN   rO   r     s    zIntNode.calculate_result_codec             C   s   t j| j| _d S )N)r   r  r   rp   )rP   rN   rN   rO   r     s    z!IntNode.calculate_constant_resultc             C   s   t j| jS )N)r   r  r   )rP   r   rN   rN   rO   r     s    zIntNode.compile_time_value)rR   rS   rT   r  r  r  r  r  r  r  r  rQ  r   r(  r   r  r   r   r   rN   rN   rN   rO   r   e  s   r   c               @   sB   e Zd ZejZdd Zdd Zdd Zdd Z	d	d
 Z
dd ZdS )r  c             C   s   t | j| _d S )N)rq   r   rp   )rP   rN   rN   rO   r     s    z#FloatNode.calculate_constant_resultc             C   sN   t | j}d| jd}tj| j}||t|jdfkrJt| jd|  |S )Nz%.330fr  zEUsing this floating point value with DEF may lose precision, using %r)	rq   r   stripr   Znormalise_float_reprreprlstripr   rr   )rP   r   Zfloat_valueZstr_float_valueZ	str_valuerN   rN   rO   r     s    
zFloatNode.compile_time_valuec             C   sX   |j r&| jjr&t| j| j| jtjdS |jrJ| jj rJt| j| j| j|dS t	j
| ||S )N)r   rp   r   )re   r   ry  r  rr   r   rp   r   Z
float_typer  rQ  )rP   rh  rg   rN   rN   rO   rQ  	  s    
zFloatNode.coerce_toc             C   s   | j S )N)r  )rP   rN   rN   rO   r     s    zFloatNode.calculate_result_codec             C   sL   | j }t|tsttt|}|dkr,dS |dkr8dS |dkrDdS |S d S )Nnanz(Py_HUGE_VAL * 0)infZPy_HUGE_VALz-infz(-Py_HUGE_VAL))r   ro   rF   r   r  rq   )rP   strvalZcmpvalrN   rN   rO   r     s    z$FloatNode.get_constant_c_result_codec             C   s,   | j  }| jjr"|j| j|| _n|| _d S )N)r   r   re   Zget_py_floatr   r  )rP   r   Zc_valuerN   rN   rO   r(  &  s    z"FloatNode.generate_evaluation_codeN)rR   rS   rT   r   c_double_typer   r   r   rQ  r   r   r(  rN   rN   rN   rO   r    s   r  c       
      C   sH  t j| }|d k	r|jr|S |j }|j| }|r||jr||j}|j r`|tjkr`|j	j
dkr`t}|rt|jsp|jrt|S |pz|}ddlm} tdd |d |d |d d f}y|d|  |d j|d	}W n tk
r   Y n\X |jjd j}	t|	tr:|	j|}	t|	tr:|	j}|r0|js,|jr0|S |p8|}W d Q R X |S )
Nr2   r%   )TreeFragmentT)ignorer      z
sizeof(%s))rf   Zinitial_pos)r   parse_basic_typein_c_type_contextglobal_scoper|  is_typer   r   int_typecontextlanguage_levelr   re   r  r   filenamer   rootstatsexprro   SizeofTypeNoder   arg_type)
rf   rr   rg   r   r  Zglobal_entryr   r  ZdeclarationZsizeof_noderN   rN   rO   _analyse_name_as_type.  s<    




r  c               @   sf   e Zd ZdZe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 Zdd Zdd ZdS )	BytesNodeTc             C   s   | j | _d S )N)r   rp   )rP   rN   rN   rO   r   _  s    z#BytesNode.calculate_constant_resultNc             C   s,   t j| j||| | jj}t| j||dS )N)r   rp   )r	   bytes_literalr   encodingr  rr   )rP   r   r   r   r   rN   rN   rO   as_sliced_nodeb  s    zBytesNode.as_sliced_nodec             C   s
   | j j S )N)r   
byteencode)rP   r   rN   rN   rO   r   f  s    zBytesNode.compile_time_valuec             C   s   t | jjd| j|S )Nz	ISO8859-1)r  r   decoderr   )rP   rg   rN   rN   rO   r   i  s    zBytesNode.analyse_as_typec             C   s   t | jdkS )Nr%   )r{   r   )rP   rN   rN   rO   can_coerce_to_char_literall  s    z$BytesNode.can_coerce_to_char_literalc             C   s   t | j}t| j||dS )N)r   rp   )r   r   rv  rr   )rP   rg   r  rN   rN   rO   r   o  s    
zBytesNode.coerce_to_booleanc             C   s(  | j |kr| S |jrZ| j s,t| jd | S |jrBt| jd | S t| j| jt| jdS t	| j| j| j
d}|jr|ttjfkrtj|_ n| j||dd |S |tjtjfkr||_ |S |tjtjtjfkr|tjkrtjntj|_ t||S |jtjr|j s|jr||_ |S tj|||S )Nz?Only single-character string literals can be coerced into ints.zRBytes literals cannot coerce to Py_UNICODE/Py_UCS4, use a unicode literal instead.)r   rp   T)rp  )r   r\  r  r   rr   is_unicode_charr   r   r  r  rp   re   r   r   r   rH  r   ra   rc   rb   rd   c_void_ptr_typeCastNoderc  r   is_constr  rQ  )rP   rh  rg   rt   rN   rN   rO   rQ  u  s:    



zBytesNode.coerce_toc             C   sP   | j jr|j| j}n0| j jr,|j| j}n| jj }t| j tj	|}|| _
d S )N)r   re   get_py_string_constr   r  get_string_constZas_c_string_literalr+   r   r  r  )rP   r   r   r  rN   rN   rO   r(    s    
z"BytesNode.generate_evaluation_codec             C   s   d S )NrN   )rP   rN   rN   rO   r     s    z$BytesNode.get_constant_c_result_codec             C   s   | j S )N)r  )rP   rN   rN   rO   r     s    zBytesNode.calculate_result_code)N)rR   rS   rT   r  r   r   r   r  r   r   r  r   rQ  r(  r   r   rN   rN   rN   rO   r  V  s   
&r  c               @   sj   e Zd ZdZdZe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 Zdd Zdd ZdS )UnicodeNodeTNc             C   s   | j | _d S )N)r   rp   )rP   rN   rN   rO   r     s    z%UnicodeNode.calculate_constant_resultc             C   s   t | j| j|S )N)r  r   rr   )rP   rg   rN   rN   rO   r     s    zUnicodeNode.analyse_as_typec             C   sv   t j| jd | rd S t j| j||| }| jj|_| jd k	r`t j| j||| | jj}nd }t| j|||dS )N)r   bytes_valuerp   )	r	   string_contains_surrogatesr   r  r  r  r  r  rr   )rP   r   r   r   r   r  rN   rN   rO   r    s    

zUnicodeNode.as_sliced_nodec             C   s   || j krn|jrJ| j s*t| jd | S t| j}t| j|t||dS |j	s|j
rx| jd k	rxt| j| jdj||S |jrt| j| j|dS t| jd n|ttjfkr| j||dd | S )NzhOnly single-character Unicode string literals or surrogate pairs can be coerced into Py_UCS4/Py_UNICODE.)r   r   rp   )r   )r   r   zUnicode literals do not support coercion to C types other than Py_UNICODE/Py_UCS4 (for characters) or Py_UNICODE* (for strings).T)rp  )r   r  r  r   rr   r  r   r   rk   re   r$  r  r  rQ  r%  r  r   r   r/   rH  )rP   rh  rg   Z	int_valuerN   rN   rO   rQ    s(    

zUnicodeNode.coerce_toc             C   s   t | jdkS )Nr%   )r{   r   )rP   rN   rN   rO   r    s    z&UnicodeNode.can_coerce_to_char_literalc             C   s   t | j}t| j||dS )N)r   rp   )r   r   rv  rr   )rP   rg   r  rN   rN   rO   r     s    
zUnicodeNode.coerce_to_booleanc             C   s   t j| jS )N)r	   r  r   )rP   rN   rN   rO   contains_surrogates  s    zUnicodeNode.contains_surrogatesc             C   s   | j jrtj| jr|jtd| _|jtj	| jj
d}|j| j}|d krRd S |j| j |jd| j|||j| j| jf  |j| jd| j  q|j| j| _n|j| j| _d S )NZustringZunicode_escapez@%s = PyUnicode_DecodeUnicodeEscape(%s, sizeof(%s) - 1, NULL); %sz__Pyx_PyUnicode_READY(%s))r   re   r	   Zstring_contains_lone_surrogatesr   get_py_constr   r  r  ZBytesLiteralencodeget_cached_constants_writerr"  rr   r   r   put_error_if_negr  Zget_pyunicode_ptr_const)rP   r   Z
data_cname
const_coderN   rN   rO   r(    s&    z$UnicodeNode.generate_evaluation_codec             C   s   | j S )N)r  )rP   rN   rN   rO   r     s    z!UnicodeNode.calculate_result_codec             C   s   | j S )N)r   )rP   rg   rN   rN   rO   r     s    zUnicodeNode.compile_time_value)N)rR   rS   rT   r  r  r   r   r   r   r  rQ  r  r   r  r(  r   r   rN   rN   rN   rO   r    s   
r  c               @   sf   e Zd ZeZdZdZ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 Zdd ZdS )
StringNodeTNc             C   s   | j d k	r| j | _d S )N)r   rp   )rP   rN   rN   rO   r   )  s    
z$StringNode.calculate_constant_resultc             C   s   t | jp| jjd| j|S )Nz	ISO8859-1)r  r   r   r  rr   )rP   rg   rN   rN   rO   r   .  s    zStringNode.analyse_as_typec             C   sx   t | j| j||| }| jj|_| jd k	r^tj| jd | rFd S tj| j||| }nd }t| j|||| j	dS )N)r   r   rp   is_identifier)
r   r   r  r   r	   r  r  r  rr   r  )rP   r   r   r   r   r   rN   rN   rO   r  1  s    

zStringNode.as_sliced_nodec             C   sP   |t k	rLtj| rL|js2t| j| jdj||S |tj	k	rL| j
||dd | S )N)r   T)rp  )r   r   r_  re   r  rr   r   rQ  r   r/   rH  )rP   rh  rg   rN   rN   rO   rQ  @  s    
zStringNode.coerce_toc             C   s   | j  ot| jdkS )Nr%   )r  r{   r   )rP   rN   rN   rO   r  K  s    z%StringNode.can_coerce_to_char_literalc             C   s   |j | j| jd| jd| _d S )NT)
identifieris_strr   )r  r   r  r   r  )rP   r   rN   rN   rO   r(  N  s    
z#StringNode.generate_evaluation_codec             C   s   d S )NrN   )rP   rN   rN   rO   r   S  s    z%StringNode.get_constant_c_result_codec             C   s   | j S )N)r  )rP   rN   rN   rO   r   V  s    z StringNode.calculate_result_codec             C   s8   | j jr| j S ts| j j S | jd k	r,| jS | j jdS )Nz	iso8859-1)r   Z
is_unicoder$   r  r   r  )rP   rg   rN   rN   rO   r   Y  s    

zStringNode.compile_time_value)N)rR   rS   rT   r   r   r  r  r   r   r   r  rQ  r  r(  r   r   r   rN   rN   rN   rO   r    s   
r  c               @   s   e Zd ZdZdS )r   TN)rR   rS   rT   r  rN   rN   rN   rO   r   e  s   r   c               @   sN   e Zd ZejZdd Zdd Zdd Zdd Z	d	d
 Z
dZdd Zdd ZdS )ImagNodec             C   s   t dt| j| _d S )Ng        )complexrq   r   rp   )rP   rN   rN   rO   r   r  s    z"ImagNode.calculate_constant_resultc             C   s   t dt| jS )Ng        )r  rq   r   )rP   r   rN   rN   rO   r   u  s    zImagNode.compile_time_valuec             C   s   | j j| | S )N)r   create_declaration_utility_code)rP   rg   rN   rN   rO   r   x  s    zImagNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r  |  s    zImagNode.may_be_nonec             C   s@   | j |kr| S t| j| jd}|jr2d|_tj|_ tj	|||S )N)r   r%   )
r   r  rr   r   re   r   r   complex_typer  rQ  )rP   rh  rg   rt   rN   rN   rO   rQ    s    
zImagNode.coerce_tozConstructing complex numberc             C   s*   | j jr| j S d| j jt| jf S d S )Nz	%s(0, %r))r   re   r   
from_partsrq   r   )rP   rN   rN   rO   r     s    zImagNode.calculate_result_codec             C   sB   | j jr>|jd| j t| j|j| j | jf  | j| d S )Nz'%s = PyComplex_FromDoubles(0.0, %r); %s)	r   re   r   r   rq   r   r   rr   r=  )rP   r   rN   rN   rO   r#    s    zImagNode.generate_result_codeN)rR   rS   rT   r   Zc_double_complex_typer   r   r   r   r  rQ  gil_messager   r#  rN   rN   rN   rO   r  k  s   r  c               @   s8   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d ZdS )NewExprNodeNc             C   sb   | j j|}|d ks|j r2t| jd t| _d S | j| |j| j}|| _	|| _
|j| _| jS )Nz/new operator can only be applied to a C++ class)Zcppclassr   r   r   rr   r,   r   	cpp_checkZget_constructor
class_typer   )rP   rg   r   constructorrN   rN   rO   rv     s    
zNewExprNode.infer_typec             C   s   | j d kr| j| | S )N)r   rv   )rP   rg   rN   rN   rO   r     s    

zNewExprNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r    s    zNewExprNode.may_be_nonec             C   s   d S )NrN   )rP   r   rN   rN   rO   r#    s    z NewExprNode.generate_result_codec             C   s   d| j j  S )Nznew )r  empty_declaration_code)rP   rN   rN   rO   r     s    z!NewExprNode.calculate_result_code)	rR   rS   rT   r   rv   r   r  r#  r   rN   rN   rN   rO   r    s   r  c                   s|  e Zd ZdZdZdZdZdZdZdZ	dZ
dZdZdZdZdd Zdd Zd	d
 Zdd Zdd Z fddZdPd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'Z dQd(d)Z!d*d+ Z"d,d- Z#d.d/ Z$ fd0d1Z%d2d3 Z&d4d5 Z'd6d7 Z(d8d9 Z)d:d; Z*d<d= Z+d>d? Z,d@dA Z-dBdC Z.dRdDdEZ/dFdG Z0dHdI Z1dSdJdKZ2dLdM Z3dNdO Z4  Z5S )TrP  TFNr   c             C   s   | j S )N)cython_attribute)rP   rN   rN   rO   r    s    zNameNode.as_cython_attributec             C   s:   | j d kr|j| j| _ | j d k	r2| j jjr2| fS f S d S )N)r   r|  rf   r   is_unspecified)rP   rg   rN   rN   rO   r     s
    
zNameNode.type_dependenciesc             C   s   | j d kr|j| j| _ | j d ks.| j jtkrB| jd k	r>| jS tS | j jjsV| j jjrj| j| j jjkrjt	S | j jj
r| j jjrtS tj| j jS n.| j jjr| jr| jjo| j js| jS | j jS d S )N)r   r|  rf   r   r-   inferred_typer   is_extension_typeis_builtin_typer   r   r{  Zis_builtin_scoper   CPtrTypere   r\  Zmight_overflow)rP   rg   rN   rN   rO   rv     s"    



zNameNode.infer_typec             C   s8   y|j | jS  tk
r2   t| jd| j  Y nX d S )Nz"Compile-time name '%s' not defined)r|  rf   r  r   rr   )rP   r   rN   rN   rO   r      s    zNameNode.compile_time_valuec             C   s   | j  s| j jjrd S | j jS )N)r   r   re   r   )rP   rN   rN   rO   r     s    z#NameNode.get_constant_c_result_codec                st   |t krb| j}|rb|jrb|j}|rb|jr>|jr>|j|j| j}t	| j| jd}||_|j
| |S tt	| j||S )N)rf   )r   r   r   as_variable
is_builtinr  declare_builtinrf   rr   rP  analyse_rvalue_entryrJ   rQ  )rP   rh  rg   r   Z	var_entryrt   )rM   rN   rO   rQ    s    

zNameNode.coerce_toc       
      C   sr  | j }| j}| jp|j|}|sX|jr,dS f }|jjsD|jd  rJd}n|jrVt	}n|j
|\}}|dkr|r|jd dkrtnt	}nH|jr|jry|j|j}W n* tk
r   t| jd| j   t}Y nX d}|jr|jdk}	|js|j|r|	rdnd	}|r8|jr8|jp |j r8t	}t|jd
d |j||| j| ||d }| _|rn|j rn||_dS )as  Implements PEP 526 annotation typing in a fairly relaxed way.

        Annotations are ignored for global variables.
        All other annotations are stored on the entry in the symbol table.
        String literals are allowed and not evaluated.
        The ambiguous Python types 'int' and 'long' are not evaluated - the 'cython.int' form must be used instead.
        NZannotation_typinginfer_typesFzR'%s' cannot be specialized since its type is not a fused argument to this functionprivatefrozenreadonlypubliczxAnnotation ignored since class-level attributes must be Python objects. Were you trying to set up an instance attribute?r2   )Zis_cdef
visibilityZpytyping_modifiers)rf   r  r   lookup_hereis_module_scoper  r  r_   is_py_class_scoper   analyse_type_annotationr-   r   r   r   r&   r   rr   r,   is_c_dataclass_scopere   can_coerce_to_pyobjectis_c_class_scoperU  r   declare_var)
rP   rg   	as_targetrf   r  r   	modifiersZatyper  	is_frozenrN   rN   rO   declare_from_annotation  sJ    


 z NameNode.declare_from_annotationc             C   sN   | j }|s|j| j}|r&|jr&|jS |rJ|jrJtj|j}|rJ|jrJ|S d S )N)r   r|  rf   	as_moduleknown_standard_library_importr   Z'get_known_standard_library_module_scoper  )rP   rg   r   r{  rN   rN   rO   r   ^  s    


zNameNode.analyse_as_modulec             C   s  d }| j rtj| j }n|jr*tj| j}|r2|S | j}|sH|j| j}|rf|j rf|jrft	j
|j}|r|jr|j}|j r|t	jkrt| jd t}n2|jr|jr|j}n|t	jkr|j jjdkrt}|S | jdkrtS |j otj| jrt| jd| j| jf  d S )NzWFound Python 2.x type 'long' in a Python annotation. Did you mean to use 'cython.long'?r2   objectzJFound C type '%s' in a Python annotation. Did you mean to use 'cython.%s'?)r  r   r  r  rf   r   r|  r  r#  r   Z get_known_standard_library_entryr   r0   r   rr   r   re   equivalent_typer  r  r  r  )rP   rg   r   r   rN   rN   rO   r   l  s6    

zNameNode.analyse_as_typec             C   s:   | j }|s|j| j}|r6|jr6|jjs0|jjr6|jS d S )N)r   r|  rf   r  r   r	  r
  )rP   rg   r   rN   rN   rO   r    s    
z"NameNode.analyse_as_extension_typec             C   s   | j |ddS )NF)is_assignment_expression)_analyse_target_declaration)rP   rg   rN   rN   rO   r     s    z#NameNode.analyse_target_declarationc             C   s   | j |ddS )NT)r&  )r'  )rP   rg   rN   rN   rO   r     s    z9NameNode.analyse_assignment_expression_target_declarationc             C   s  d| _ | js.|r |j| j| _n|j| j| _| jr<d| j_| j rf| jd k	rf|j}| j|| d n&| jr| jj	r| jr|jrt
| jd | js|jd rt| jd| j d |jd d	krt}nt}|r|j| j|| j| _n|j| j|| j| _| jjrt| _| jjrd| j_d S )
NTrD  )r  z7Cannot redeclare inherited fields in Cython dataclasseszwarn.undeclaredzimplicit declaration of '%s'r%   r  F)r  r   Z#lookup_assignment_expression_targetrf   r  r#  r  r  r!  Zis_inheritedr   rr   r_   r   r-   r   Z$declare_assignment_expression_targetr  is_declared_genericr   r"  is_variable)rP   rg   r&  Zis_dataclassr   rN   rN   rO   r'    s4    


z$NameNode._analyse_target_declarationc             C   s   |j d | _| j}|d krf|j| j}|sP|j| j| j}|rP|jrP|jrPd| _	|s`t
j| _| S || _d|_|jjrddlm} |j| | j| | S )NinitializedcheckTr%   )Buffer)r_   initialized_checkr   r|  rf   r  rr   r  r  r   r   r,   r   rN  	is_bufferrD  r+  used_buffer_aux_varsr  )rP   rg   r   r+  rN   rN   rO   r     s$    

zNameNode.analyse_typesc             C   s   | j |dd | j}|jrR|jrR|js>|jjs>| j  rR|jrR|j }| _|j| _| jjrlt	| j
d| j  | j st	| j
d| j  tj| _d|_|jjrddlm} |j| | S )NT)r  zAssignment to const '%s'zAssignment to non-lvalue '%s'r%   )r+  )analyse_entryr   r   r  is_overridabler   r   fused_cfunctionr  r   rr   rf   r   r,   rN  r-  rD  r+  r.  )rP   rg   r   r+  rN   rN   rO   r     s     
zNameNode.analyse_target_typesc             C   sh   | j | | j}|jrt| _|js(|jrJ|jr<|jr<d| _nd| _d| _	n|j
jrdd| _d| _	d| _| S )Nr   r%   FT)r/  r   r(  r   r   is_pyglobalr  r  r   is_used_as_rvaluer   r   r  )rP   rg   r   rN   rN   rO   r    s    
zNameNode.analyse_rvalue_entryc             C   s:   d| _ | jr6| j}|jr(|js6| j  n|jr6| j  d S )NT)r   r3  r   r  r  r  r2  )rP   rg   r   rN   rN   rO   r  	  s    
zNameNode.nogil_checkz"Accessing Python global or builtinc             C   s>   | j   | j}|j}| r4|jr4| jr4| jjr4| j}|| _d S )N)check_identifier_kindr   r   re   r  r
  )rP   rg   r  r   r   rN   rN   rO   r/  	  s    zNameNode.analyse_entryc             C   s   | j }|jr|jjr|| _|jrX|jjs0|jjrXtj| j	d t
}d|_| j j|_|| _ nJ|jpt|jpt|jpt|jpt|js| j jr| j j| _ n| jst| jd| j	  d S )NTz7'%s' is not a constant, variable or function identifier)r   r  r   r	  
type_entryrw  is_cpp_enumr   Entryrf   r   r2  r{  r  r)  r  r   r   r  is_cython_moduler   rr   )rP   r   Zpy_entryrN   rN   rO   r4  	  s    
zNameNode.check_identifier_kindc             C   s0   | j s| jrdS | jp |j| j}|jo.|j S )NF)r8  r  r   r|  rf   r"  r)  )rP   rg   r   rN   rN   rO   "is_cimported_module_without_shadow2	  s    z+NameNode.is_cimported_module_without_shadowc             C   s   dS )Nr%   rN   )rP   rN   rN   rO   r  8	  s    zNameNode.is_simplec                sl   | j r^| jr^| jjs| jjr^t| ddr,dS d| _d}x| j D ]}|jj r>d}P q>W | `|S tt	| j S )N_none_checkingFT)
rz   r   re   r   r   r:  r|   r  rJ   rP  )rP   r  
assignment)rM   rN   rO   r  <	  s    
zNameNode.may_be_nonec             C   s<   t j| rdS | j}| s |jr$dS |jp:|jp:|jp:|jS )NTF)r   r   r   
in_closureis_localZis_argr  is_readonly)rP   r   rN   rN   rO   r   Q	  s    
zNameNode.nonlocally_immutablec             C   s   d S )NrN   )rP   rg   rN   rN   rO   calculate_target_resultsY	  s    z!NameNode.calculate_target_resultsc             C   s:   | j }|d k	r6|jp&|jp&|jp&|jj r6| j  dS dS )NFT)r   r  r   r  r   r  )rP   r   rN   rN   rO   r   \	  s    
zNameNode.check_constc             C   s(   | j }|jp|jp|js$| j  dS dS )NFT)r   
is_cglobalr   r  r  )rP   r   rN   rN   rO   r	  g	  s
    zNameNode.check_const_addrc             C   s"   | j jr| j j p | j jo | j jS )N)r   r)  r>  r   r0  )rP   rN   rN   rO   r   n	  s    
zNameNode.is_lvaluec             C   s   | j jo| jj S )N)r   r)  r   r   )rP   rN   rN   rO   r   w	  s    zNameNode.is_addressablec             C   s   dS )Nr   rN   )rP   rN   rN   rO   r   z	  s    zNameNode.is_ephemeralc             C   s.   | j }|sdS | j jr(| j r(d|j S |jS )Nz<error>z(*%s))r   is_cpp_optionalr  r   )rP   r   rN   rN   rO   r   	  s    
zNameNode.calculate_result_codec       	      C   sF  | j }|d krd S |jr&|jj|j |jr6|jr6d S |jr|jjsNt	d|j
| j j}|jrjtj}n|jj}| js|jd| j ||f  |jd| j   |jd |jjtjdd |jd| j |f  | js|jd |j|j| j | j | j| n6|jr|jj r|jjs2t	d|j
| j j}|jjtjd	d |jd
| j ||j| j | jf  | j| n|js|jrT|jjrT|jjst	d|j
| j j}|jjr|jjtjdd |jd| j ||j| j | jf  n@|jjtjdd |jd| j |jj||j| j | jf  | j| n|jsv|jsv|jsv|jjr
| js| jo| j }|jjo| j }|j!o| j }|r|jj"|j#}n|jj$|j#}|rB|rB|jjs|s|rB|j%| j|| j&|d n8|j'rB|j!rB| j rB|jj"|j#}|j%| j||d d S )Nz,Python global or builtin not a Python objectz%s = PyObject_GetItem(%s, %s);zif (unlikely(!%s)) {zPyErr_Clear();ZGetModuleGlobalNamezObjectHandling.cz"__Pyx_GetModuleGlobalName(%s, %s);r   ZGetBuiltinNamez!%s = __Pyx_GetBuiltinName(%s); %sz%__Pyx_GetModuleGlobalName(%s, %s); %sZGetNameInClassz$__Pyx_GetNameInClass(%s, %s, %s); %s)unbound_check_code)(r   utility_coder   r   r  r  is_pyclass_attrr   re   r   intern_identifierrf   r   Zbuiltins_cnamer{  namespace_cnamer7  r   r   r   r   r   rr   r=  r  r2  r=  r<  from_closurer   r8  
allow_nullr,  rA   cpp_optional_check_for_null_coder   Zcheck_for_null_codeput_error_if_unboundr  r@  )	rP   r   r   interned_cname	namespaceZraise_unboundZmemslice_checkZoptional_cpp_checkrB  rN   rN   rO   r#  	  s    




""zNameNode.generate_result_codec             C   sR  | j }|d krd S | j jjrBt|trB| j rB|j rBt| jd |j	rD|jj
sZtd|j| j j}| j jj}|jr~d}	nZ|jjrd}	tj}nF|jr| jdkrdnd}
|jjtj|
d d	|
 }	nd
stt||j| jd|	|||j f  trtd td|  |j| |j| |jrN|j d|jj!j"  n
| jj#r\| j$|| n| jj%rr| j&|| d
}| jj
r8| j'r8|j(| |j)p| j j*p| j j+}|r| j,|dd d}|j)r| j-||j.| j/  nD| j0s$| j1r| j2||j.| j/  n| j-||j.| j/  nd
}|r8|j3| | jj#s0|s
|r|j4 }|dkrt5|| jd| j6 |f | jj
r| j6 nd || j7 n|j d| j6 |f  n\|j8| j/ }t9| jr|j d| j6 | j6 |f  n$|| j6 kr
|j d| j6 |f  tr$td td|  |j:| n|j; rD|j:| |j| d S )Nz?Literal list must be assigned to pointer at time of declarationz,Python global or builtin not a Python objectZ__Pyx_SetItemOnTypeDictPyDict_SetItemrK   ZSetNewInClassZSetNameInClasszObjectHandling.cZ__Pyx_Fz%s(%s, %s, %s)z"NameNode.generate_assignment_code:z"...generating disposal code for %szPyType_Modified(%s);T)r;  r   z%s = %s;znew (&%s) decltype(%s){%s};z)...generating post-assignment code for %s)<r   r   rJ  ro   ListNodelhs_of_first_assignmentin_module_scoper   rr   r2  re   r   rE  rf   r{  rF  	is_memberr  r   moddict_cnamerD  r   r   r   r   r  r  r   r   printr+  r1  r   Zparent_typeZtypeptr_cnamer    generate_acquire_memoryviewslicer-  generate_acquire_bufferr  r  r@  r<  rG  r=  r5  r   r   r7  r8  r6  r@  r   r   r   r  r   r9   r,  r
  )rP   r|   r   r-  r   r   r   rK  rL  setternassignedZis_external_refr   rN   rN   rO   r.  	  s    












z!NameNode.generate_assignment_codec          	   C   s6   ddl m} |j| j | j| j||| j | jd dS )z
        Slices, coercions from objects, return values etc are new references.
        We have a borrowed reference in case of dst = src
        r%   )rE  )Z	lhs_cnamer   Zlhs_posr|   r   r  Zfirst_assignmentN)rD  rE  Zput_acquire_memoryviewslicer   r   rr   r  r7  )rP   r|   r   rE  rN   rN   rO   rT  R
  s    z)NameNode.generate_acquire_memoryviewslicec             C   s   t |tp|j}|r$|j| j }n0|jj| jjdd}|j	d||j| j f  ddl
m} |j| j || j| j | j|d |s|j	d|  |jj| d S )NF)r  z%s = %s;r%   )r+  )Zis_initializedrr   r   z%s = 0;)ro   rP  r   r   r   r  r  r   r   r   rD  r+  Zput_assign_to_bufferr   rO  rr   r  )rP   r|   r   Z
pretty_rhsZrhstmpr+  rN   rN   rO   rU  b
  s    z NameNode.generate_acquire_bufferc             C   s~  | j d krd S | j jrf| j jj}|j| j j}|r8d}nd| j j }|jd||||j| jf  n| j j	r|j
jtjdd |j| j j}dtj|f }|r|jd||j| jf  n|j| j| n| j jjs| j jjrn| jsz| jo| r
|j| j| j  | j jr$| j|d|d	 |rP| jrP|j| j | j | j d
 n|j| j | j | j d
 nt| jd d S )NzPyErr_Clear(); elsezT{ PyErr_Clear(); PyErr_Format(PyExc_NameError, "name '%%s' is not defined", "%s"); }ziif (unlikely(PyObject_DelItem(%s, %s) < 0)) { if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) %s %s }PyObjectSetAttrStrzObjectHandling.cz!__Pyx_PyObject_DelAttrStr(%s, %s)zjif (unlikely(%s < 0)) { if (likely(PyErr_ExceptionMatches(PyExc_AttributeError))) PyErr_Clear(); else %s }T)r;  r<  )r  z!Deletion of C names not supported)r   rD  r{  rF  rE  rf   r   r   rr   r2  r   r   r   r   r   module_cnamer  r   re   r   r7  r8  rJ  r<  r=  put_xdecref_clearr   r   r   r*  r   )rP   r   r/  rL  rK  Zkey_error_codeZdel_coderN   rN   rO   r0  v
  sJ    



zNameNode.generate_deletion_codec             C   sv   t | ddrr| jd | jd | jd t| j d f}| jjrHd\}}nd\}}|j|t||| j t| jd
 d S )N	is_calledFr   r%   r2   py_callpython function (%s)c_callc function (%s))size)r]  r^  )r_  r`  )r   rr   r{   rf   r   re   rC  r3   )rP   r   rr   styletextrN   rN   rO   rC  
  s    *
zNameNode.annotatec             C   s   | j r| j jS d S )N)r   r#  )rP   rN   rN   rO   r  
  s    z*NameNode.get_known_standard_library_import)F)F)FNN)F)6rR   rS   rT   r   r8  r  rO  r3  r   r5  r8  r7  rH  r   r  r  r   rv   r   r   rQ  r!  r   r   r  r   r   r'  r   r   r  r  r   r/  r4  r9  r  r  r   r?  r   r	  r   r   r   r   r#  r.  rT  rU  r0  rC  r  rU   rN   rN   )rM   rO   rP    sf   
@'#

	[ 
o
2	rP  c               @   s2   e Zd ZeZdgZdd ZdZdd Zdd Z	d	S )
BackquoteNodeargc             C   s&   | j j|| _ | j j|| _ d| _| S )Nr%   )re  r   rr  r   )rP   rg   rN   rN   rO   r   
  s    zBackquoteNode.analyse_typeszBackquote expressionc             C   s   t | jj| _d S )N)r  re  rp   )rP   rN   rN   rO   r   
  s    z'BackquoteNode.calculate_constant_resultc             C   s:   |j d| j | jj |j| j | jf  | j| d S )Nz%s = PyObject_Repr(%s); %s)r   r   re  r   r   rr   r=  )rP   r   rN   rN   rO   r#  
  s    z"BackquoteNode.generate_result_codeN)
rR   rS   rT   r   r   r   r   r   r   r#  rN   rN   rN   rO   rd  
  s   rd  c               @   sB   e Zd ZeZdZdZdZdddgZdd Z	d	Z
d
d Zdd ZdS )
ImportNodeNFTmodule_name	name_listmodule_namesc                s    j d kr>|j jr8|jd s0tj|j jjkr8d _ nd _  jj	|}|j
| _ jjsbt jr jj	|}|j
| _nDd jjkrt jj fddttj jjjdD dj	| _ S )	NZ
py2_importr%   r   .c                s   g | ]}t  jj||d qS ))r   rp   )r   rg  rr   )rW   part)rP   rN   rO   r   
  s   z,ImportNode.analyse_types.<locals>.<listcomp>)r   )rn   r  parent_moduler_   r4   r   r  Zfuture_directivesrg  r   rr  r  r   rh  r   	TupleNoderr   mapr	   r  r  ri  )rP   rg   rg  rh  rN   )rP   rO   r   
  s$    



zImportNode.analyse_typeszPython importc             C   sN  | j jst| j j}| jdkr| j r| j r| jr@| jjs@t| jdkr\t	j
dd}d}nt	j
dd}d}|jj| d|| j j | jr| jj ndf }n:|jjt	j
d	d d
| j j | jr| jj nd| jf }| jdko|tkrt| \}}}|jjt	j
|| d||f }|jd| j ||j| j | jf  | j| d S )Nr   ZImportDottedModulezImportExport.cZ__Pyx_ImportDottedModuleZImportDottedModuleRelFirstZ __Pyx_ImportDottedModuleRelFirstz
%s(%s, %s)r  Importz__Pyx_Import(%s, %s, %d)r  z%s(%s)z%s = %s; %s)rg  r  r   r   rn   rh  get_top_level_moduleri  r   r   r   r   r   r   r)   r   r   r   rr   r=  )rP   r   rg  rC  Zhelper_funcZimport_codeZ	code_nameZ	code_filerN   rN   rO   r#    s:    

zImportNode.generate_result_codec             C   s   | j jS )N)rg  r   )rP   rN   rN   rO   r  *  s    z,ImportNode.get_known_standard_library_import)rR   rS   rT   r   r   ri  rq  r   r   r   r   r#  r  rN   rN   rN   rO   rf  
  s   
%rf  c                   sZ   e Zd Zg ZdZdZdddZdd Zdd Zd	d
 Z	dd Z
 fddZdd Z  ZS )ScopedExprNodeNTc             C   s4   |d k	r|| _ n | jr$tj|| _ n| j s0d | _ d S )N)
expr_scopehas_local_scoper   ZComprehensionScope)rP   outer_scopers  rN   rN   rO   
init_scope=  s    zScopedExprNode.init_scopec             C   s   | j | d S )N)rv  )rP   rg   rN   rN   rO   analyse_declarationsE  s    z#ScopedExprNode.analyse_declarationsc             C   s   d S )NrN   )rP   rg   rN   rN   rO   analyse_scoped_declarationsH  s    z*ScopedExprNode.analyse_scoped_declarationsc             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   L  s    zScopedExprNode.analyse_typesc             C   s   | S )NrN   )rP   rg   rN   rN   rO   analyse_scoped_expressionsP  s    z)ScopedExprNode.analyse_scoped_expressionsc                sN  t t| j}| j s| jj r*|| d S |jd g }xDtdd | jjj	 D D ]&\}}|j
sT|jjrT|jrT|j| qTW |s|| |jd d S |j }|j }|| | j|| |jd}|j| xT|j|fgtt|j | D ]2\}	}
|j|	r|j|	 | j|| |j|
 qW |j| |jd |j| ||_d S )Nz{ /* enter inner scope */c             s   s   | ]}|d  r|V  qdS )r   NrN   )rW   rw   rN   rN   rO   rZ   ^  s    z:ScopedExprNode.generate_evaluation_code.<locals>.<genexpr>z} /* exit inner scope */
exit_scope)rJ   rr  r(  rt  rs  var_entriesr   sortedentriesitemsr<  r   re   rN  r   Znew_loop_labelsZnew_error_label_generate_vars_cleanup	new_labelput_gotoerror_labelr   zipZget_loop_labelsZ
label_used	put_labelZset_loop_labels)rP   r   Zgenerate_inner_evaluation_code
py_entries_r   Zold_loop_labelsZold_error_labelrz  labelZ	old_label)rM   rN   rO   r(  T  s<    
$







z'ScopedExprNode.generate_evaluation_codec             C   s:   x4|D ],}|j r(|j| |j|d q|j| qW d S )Nr  )r@  Zput_var_gotrefZput_var_decref_setZput_var_xdecref_clear)rP   r   r  r   rN   rN   rO   r    s
    

z%ScopedExprNode._generate_vars_cleanup)N)rR   rS   rT   r   rs  rt  rv  rw  rx  r   ry  r(  r  rU   rN   rN   )rM   rO   rr  .  s   
,rr  c               @   s   e Zd ZeZdZdZdZdZdZ	dgZ
dd ZdZejejejejdejdgZdd	 Zd
d Zdd Zdd Zdd Zdd Zdd ZdS )IteratorNodeNFsequencec             C   s   | j r| j }| jj|| _| jjjs.| jjjrF| jjj rF| jj| _nz| jjjrft| j	| jdj|S | j
 r| jjjd j}t| j	|ddj|S | jj|| _| jjttfkr| jjd| _d| _| S )N)r  r   T)r  reversedz!'NoneType' object is not iterabler%   )rs  r  r   r   r   rJ  r$  r   CppIteratorNoderr   is_reversed_cpp_iteration	arg_tupler   re  rr  r   r   r  r   )rP   rg   r  rN   rN   rO   r     s     
zIteratorNode.analyse_typeszIterating over Python objectitc             C   s   t | jto$| jjo$t| jjjdks*dS | jj}|jr~|jdkr~|j	j
sNdS | jjjd }t |tr~|jjr~|jj	}|jjS dS )z
        Returns True if the 'reversed' function is applied to a C++ iterable.

        This supports C++ classes with reverse_iterator implemented.
        r%   Fr  r   )ro   r  r}  r  r{   r   ru  r   rf   r   r  CoercionNodere  r   r   )rP   funcre  rN   rN   rO   r    s    z&IteratorNode.is_reversed_cpp_iterationc             C   s   | j j| jp|S )N)r  r   rs  )rP   rg   rN   rN   rO   r     s    zIteratorNode.type_dependenciesc             C   sN   | j j|}|js|jr|S |jr@|jjd}|d k	rJ|jjS n
|j	rJ|S t
S )Nbegin)r  rv   r   rJ  r   r{  r|  r   return_typere   r   )rP   rg   sequence_typer  rN   rN   rO   rv     s    
zIteratorNode.infer_typec             C   s  | j j}|jrdstd|js&|jr.td|ttfk}|sN| j	 sNtd|j
 | _| jr||jd| j j | j j f  |s| jr>|jd| j | j j | j f  |jjtjdd| _| j	r.|tkrd}nd	}|jd
| j|| j f  |jd |j|j| j| j |jd |jd| j  n|jd| j  |s|jj| jdd| _| jr|jd| j  |jd |jd| j  |jd| j | j j |j| j | jf  | j| |jd| j| j |j| j| jf  | jr|jd d S )NFz+Should have been changed to CppIteratorNodez#for in carray slice not transformedzBinternal error: reversed() only implemented for list/tuple objectsz>if (likely(PyList_CheckExact(%s)) || PyTuple_CheckExact(%s)) {z%s = %s; __Pyx_INCREF(%s);)r  Z__Pyx_PyList_GET_SIZEZ__Pyx_PyTuple_GET_SIZEz%s = %s(%s);z#if !CYTHON_ASSUME_SAFE_MACROSz#endifz--%s;z%s = 0;z
%s = NULL;z} else {z	%s = -1; z%s = PyObject_GetIter(%s); %sz+%s = __Pyx_PyObject_GetIterNextFunc(%s); %sr   )r  r   r   r   r   rJ  r   r   r   r  r
  may_be_a_sequencer   r   r   r  r  r   r   counter_cnameerror_goto_if_negrr   _func_iternext_typeiter_func_ptrputr   r=  )rP   r   r  Zis_builtin_sequenceZlen_funcrN   rN   rO   r#    s^    





z!IteratorNode.generate_result_codec             C   s  | j std|dkstd|| j f }d}| jjrzt| jj}| jjd krX|}d}n"t| jjj	t
rz|| jjj	 }d}|r|jd| j |f  nh|jd |jd	tj|f  |jd
 |j|jtj| j |jd |jd| j tjf  |jd | jr
d}nd}|jd |jd||| j | j || j ||jd| jf  |jd |jd|| j | j | j ||j|| jf  |j|t |jd d S )Nz/internal error: counter_cname temp not preparedListTuplez__Pyx_Py%s_GET_SIZE(%s)FTzif (%s >= %s) break;{zPy_ssize_t %s = %s;z#if !CYTHON_ASSUME_SAFE_MACROSz#endifr   z--z++z<#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFSz6%s = Py%s_GET_ITEM(%s, %s); __Pyx_INCREF(%s); %s%s; %sr  z#elsez,%s = __Pyx_PySequence_ITEM(%s, %s); %s%s; %s)r  r  )r  r   r   r  ry   r{   r   r   ro   rp   r#   r   r   quick_temp_cnamer  rr   r  r   r:  r   )rP   Z	test_nameresult_namer   Z
final_sizeZsize_is_safeZ
item_countZinc_decrN   rN   rO   generate_next_sequence_item  s\    





z(IteratorNode.generate_next_sequence_itemc             C   sR  | j j}| jr|jd| j  |tkr8| jd|| d S |tkrR| jd|| d S | jr|jd| j	  |jd| j
   | jd|| |jd | jd|| |jd |jd |jd	 |jd
|| j	| j
 f  |jd|  |jd |jd |jd |jd|j| j  |jd |jd |jd |j|t |jd d S )Nzif (%s < 0) break;r  r  zif (likely(!%s)) {z$if (likely(PyList_CheckExact(%s))) {z} else {r   z} else r  z%s = %s(%s);zif (unlikely(!%s)) {z&PyObject* exc_type = PyErr_Occurred();zif (exc_type) {z\if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();zelse %szbreak;)r  r   r  r   r  r   r  r   r  r  r   r  r   rr   r:  r   )rP   r  r   r  rN   rN   rO   generate_iter_next_result_codeJ  sB    









z+IteratorNode.generate_iter_next_result_codec             C   s>   | j r|jj| j  | jr.|jj| j d | _tj| | d S )N)r  r  r  r  r   r1  )rP   r   rN   rN   rO   r1  o  s    zIteratorNode.free_temps)rR   rS   rT   r   r   r  r  r  is_asyncrt  r   r   r   r   r  	CFuncTypeCFuncTypeArgr  r  r   rv   r#  r  r  r1  rN   rN   rN   rO   r    s&   =7%r  c               @   sf   e Zd ZdZdZdZdZdZdg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 )r  Nrj  rD  TFr  c             C   s   | j s
dS dS )Nr  endrbeginrend)r  r  )r  r  )r  )rP   rN   rN   rO   get_iterator_func_names  s    z'CppIteratorNode.get_iterator_func_namesc             C   s  | j j}|jr|j}| j \}}|jj|}|jj|}|d ksR|jj sR|jjrtt	| j
d|| j jf  t| _| S |d ks|jj s|jjrt	| j
d|| j jf  t| _| S |jj}|jr|jd rd| _|j| j
d||jjgd krt	| j
d|| j jf  t| _| S |j| j
d|gd krJt	| j
d|| j jf  t| _| S |j| j
d|gd krt	| j
d|| j jf  t| _| S || _nP|jr||jjkst	| j
d	||f  || _nt	| j
d
|| j jf  t| _| S )Nzmissing %s() on %s
cpp_localsr   z!=z*missing operator!= on result of %s() on %sz++z*missing operator++ on result of %s() on %sz)missing operator* on result of %s() on %sz$incompatible types for %s() and %s()z8result type of %s() on %s must be a C++ class or pointer)r  r   rJ  rK  r  r{  r|  r   r   r   rr   r,   r  r   r_   extra_dereferencelookup_operator_for_types)rP   rg   r  
begin_nameend_namer  r  Z	iter_typerN   rN   rO   r     sZ    


zCppIteratorNode.analyse_typesc             C   s   | j j}| j \}}| j j rB|jd| j | j j | j|f  n|}|jrXtj	|j
}|jsj|jjd rpd| _|jj|dd| _|jd| j|jrdnd| j j f  |jd| j | j| j|f  d S )	Nz%s = %s%s%s();r  z->F)r  z
%s = %s%s;&rD  )r  r   r  r  r   r   cpp_attribute_opr   r   r  rI  rJ  r   r_   r  r  cpp_sequence_cnamer   )rP   r   r  r  r  Z	temp_typerN   rN   rO   r#    s,    

z$CppIteratorNode.generate_result_codec             C   sn   | j  \}}|jd| j| j | jp*| jj | j|f  |jd|| j| j f  |jd| j| j f  d S )Nzif (!(%s%s != %s%s%s())) break;z%s = *%s%s;z++%s%s;)r  r   r  r   r  r  r  )rP   r  r   r  r  rN   rN   rO   r    s    
z.CppIteratorNode.generate_iter_next_result_codec             C   s   | j s
d S tj| | d S )N)r  r   r&  )rP   r   rN   rN   rO   r&    s    z.CppIteratorNode.generate_subexpr_disposal_codec             C   s   | j s
d S tj| | d S )N)r  r   r'  )rP   r   rN   rN   rO   r'    s    z"CppIteratorNode.free_subexpr_tempsc             C   s.   | j stj| | tj| | tj| | d S )N)r  r   r&  r'  r+  )rP   r   rN   rN   rO   r+    s    z&CppIteratorNode.generate_disposal_codec             C   s$   | j r|jj| j  tj| | d S )N)r  r  r  r   r1  )rP   r   rN   rN   rO   r1     s    zCppIteratorNode.free_temps)rR   rS   rT   r  r  r  r   r  r   r  r   r#  r  r&  r'  r+  r1  rN   rN   rN   rO   r  x  s   0$r  c               @   s>   e Zd Zdd Zdd Zdd Zddd	Zd
d Zdd ZdS )NextNodec             C   s   t j| |j || _d S )N)r  r  rr   iterator)rP   r  rN   rN   rO   r    s    zNextNode.__init__c             C   s   d S )NrN   )rP   rg   rN   rN   rO   r    s    zNextNode.nogil_checkc             C   s   | j j|S )N)r  r   )rP   rg   rN   rN   rO   r     s    zNextNode.type_dependenciesNc             C   s   |d kr| j j|}|js |jr&|jS |jrT|j| jd|gjj	}t
j|dd}|S t| j| j jt| jdt
jdd}|j|S d S )Nr   T)Zremove_fakerefPY_SSIZE_T_MAX)r   r   )r   r   )r  rv   rJ  r   rK  r   r  rr   r   r  r   Zremove_cv_refr   r  r   r   )rP   rg   Ziterator_type	item_typeZfake_index_noderN   rN   rO   rv     s    zNextNode.infer_typec             C   s   | j || jj| _d| _| S )Nr%   )rv   r  r   r   )rP   rg   rN   rN   rO   r   ,  s    zNextNode.analyse_typesc             C   s   | j j| j | d S )N)r  r  r   )rP   r   rN   rN   rO   r#  1  s    zNextNode.generate_result_code)N)	rR   rS   rT   r  r  r   rv   r   r#  rN   rN   rN   rO   r    s   
r  c               @   s:   e Zd ZdgZdZeZdZdZdd Z	dd Z
d	d
 ZdS )AsyncIteratorNoder  Tr%   Fc             C   s   t S )N)r   )rP   rg   rN   rN   rO   rv   C  s    zAsyncIteratorNode.infer_typec             C   sB   | j r| j }| jj|| _| jjjs>t| jd | jj|| _| S )Nz*async for loops not allowed on C/C++ types)rs  r  r   r   re   r   rr   rr  )rP   rg   rN   rN   rO   r   F  s    
zAsyncIteratorNode.analyse_typesc             C   sN   |j jtjdd |jd| j | jj |j| j | j	f  | j
| d S )N	AsyncIterzCoroutine.cz)%s = __Pyx_Coroutine_GetAsyncIter(%s); %s)r   r   r   r   r   r   r  r   r   rr   r=  )rP   r   rN   rN   rO   r#  O  s    z&AsyncIteratorNode.generate_result_codeN)rR   rS   rT   r   r  r   r   r   rt  rv   r   r#  rN   rN   rN   rO   r  5  s   	r  c               @   s4   e Zd ZeZdZdd Zdd Zdd Zdd	 Z	d
S )AsyncNextNoder%   c             C   s   t j| |j || _d S )N)r  r  rr   r  )rP   r  rN   rN   rO   r  c  s    zAsyncNextNode.__init__c             C   s   t S )N)r   )rP   rg   rN   rN   rO   rv   g  s    zAsyncNextNode.infer_typec             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   j  s    zAsyncNextNode.analyse_typesc             C   sN   |j jtjdd |jd| j | jj |j| j | j	f  | j
| d S )Nr  zCoroutine.cz*%s = __Pyx_Coroutine_AsyncIterNext(%s); %s)r   r   r   r   r   r   r  r   r   rr   r=  )rP   r   rN   rN   rO   r#  m  s    z"AsyncNextNode.generate_result_codeN)
rR   rS   rT   r   r   r   r  rv   r   r#  rN   rN   rN   rO   r  X  s   r  c               @   s,   e Zd ZddgZdZdZdd Zdd ZdS )	WithExitCallNoder   
await_exprTNc             C   s4   | j j|| _ | jr"| jj|| _tj| _d| _| S )NT)r   r   r  r   rx  r   r   )rP   rg   rN   rN   rO   r     s    zWithExitCallNode.analyse_typesc             C   sx  | j r|jd| jj  | jj| |jjtdd}|j	| j
 |jjtjdd |jd|| jj| jj f  |j| jjtd | jj| | jj| |j|j|| j
 |j|t | jr| jj||dd	 |jd
|| jj f  | jj| | jj| | jr.| j| |jd| j |f  |j|td | jrV|j| j
| j  |jj| | j rt|jd d S )Nz	if (%s) {F)r  PyObjectCallzObjectHandling.cz'%s = __Pyx_PyObject_Call(%s, %s, NULL);)r   T)source_cnamedecref_sourcez%s = %s;z%s = __Pyx_PyObject_IsTrue(%s);r   )test_if_runr   Z	with_statZexit_varr   r(  r  r  r   r"  rr   r   r   r   r   r   r*  r+  r1  r   r:  r  r   r,  r  r  r  r  )rP   r   Z
result_varrN   rN   rO   r(    s<    


z)WithExitCallNode.generate_evaluation_code)rR   rS   rT   r   r  r  r   r(  rN   rN   rN   rO   r  v  s
   r  c               @   s8   e Zd ZeZdd Zdd Zdd Zdd Zd	d
 Z	dS )ExcValueNodec             C   s   t j| | d S )N)r   r  )rP   rr   rN   rN   rO   r    s    zExcValueNode.__init__c             C   s
   || _ d S )N)var)rP   r  rN   rN   rO   set_var  s    zExcValueNode.set_varc             C   s   | j S )N)r  )rP   rN   rN   rO   r     s    z"ExcValueNode.calculate_result_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r#    s    z!ExcValueNode.generate_result_codec             C   s   | S )NrN   )rP   rg   rN   rN   rO   r     s    zExcValueNode.analyse_typesN)
rR   rS   rT   r   r   r  r  r   r#  r   rN   rN   rN   rO   r    s   r  c               @   sZ   e Zd Zg Zd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 )TempNodeNc             C   s(   t j| | || _|jrt| _d| _d S )Nr%   )r   r  r   re   r   r   r   )rP   rr   r   rg   rN   rN   rO   r    s
    zTempNode.__init__c             C   s   | S )NrN   )rP   rg   rN   rN   rO   r     s    zTempNode.analyse_typesc             C   s
   d| _ d S )NT)r  )rP   rg   rN   rN   rO   r     s    z#TempNode.analyse_target_declarationc             C   s   d S )NrN   )rP   r   rN   rN   rO   r#    s    zTempNode.generate_result_codec             C   s   |j j| jdd| _d S )NT)r  )r  r  r   
temp_cname)rP   r   rN   rN   rO   allocate  s    zTempNode.allocatec             C   s   |j j| j d | _d S )N)r  r  r  )rP   r   rN   rN   rO   release  s    zTempNode.releasec          	   C   s&   y| j S    dstd Y nX d S )NFz-Remember to call allocate/release on TempNode)r  r   )rP   rN   rN   rO   r     s
    zTempNode.resultc             C   s   d S )NrN   )rP   r   rN   rN   rO   r    s    zTempNode.allocate_temp_resultc             C   s   d S )NrN   )rP   r   rN   rN   rO   r    s    zTempNode.release_temp_result)N)rR   rS   rT   r   r  r   r   r#  r  r  r   r  r  rN   rN   rN   rO   r    s   	
r  c               @   s   e Zd Zdd ZdS )
PyTempNodec             C   s   t j| |tj| d S )N)r  r  r   r   )rP   rr   rg   rN   rN   rO   r    s    zPyTempNode.__init__N)rR   rS   rT   r  rN   rN   rN   rO   r    s   r  c               @   s:   e Zd Zg ZdddZdd Zdd Zdd	 Zd
d ZdS )RawCNameExprNodeNc             C   s"   t j| ||d |d k	r|| _d S )N)r   )r   r  r   )rP   rr   r   r   rN   rN   rO   r    s    zRawCNameExprNode.__init__c             C   s   | S )NrN   )rP   rg   rN   rN   rO   r     s    zRawCNameExprNode.analyse_typesc             C   s
   || _ d S )N)r   )rP   r   rN   rN   rO   	set_cname
  s    zRawCNameExprNode.set_cnamec             C   s   | j S )N)r   )rP   rN   rN   rO   r     s    zRawCNameExprNode.resultc             C   s   d S )NrN   )rP   r   rN   rN   rO   r#    s    z%RawCNameExprNode.generate_result_code)NN)	rR   rS   rT   r   r  r   r  r   r#  rN   rN   rN   rO   r    s   
r  c               @   s6   e Zd ZeZdZdZdgZdd Zdd Z	dd	 Z
d
S )JoinedStrNodeTzString concatenationvaluesc                s    fdd| j D | _ | S )Nc                s   g | ]}|j  j qS rN   )r   rr  )rW   v)rg   rN   rO   r   '  s    z/JoinedStrNode.analyse_types.<locals>.<listcomp>)r  )rP   rg   rN   )rg   rO   r   &  s    zJoinedStrNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r  *  s    zJoinedStrNode.may_be_nonec             C   s  |j | j t| j}|jjtdd}|jjtjdd}|jjtj	dd}|j
d|||j|| jf  |j|t |j
d|  |j
d|  xxt| jD ]h\}}|j| |j| d|j  }d|j  }	d}
t|try$|jjd	 d
}	|jjd d}
W nl tk
rt   |	d
krpttt|j}|dk rRd}	tt|j}n|dkrpd}	tt|j}n Y nX tt|j}nt|tr|jjjrd}
|
s|j
d||	||	|f  |j
d||f  |j| |j
d|||j f  |j| |j| qW |j | j | j | |j!j"t#j$dd |j
d| j% |||||j| j | jf  | j&| |j'|t |jj(| |jj(| |jj(| d S )NT)r  Fz%s = PyTuple_New(%s); %sz%s = 0;z	%s = 127;z__Pyx_PyUnicode_GET_LENGTH(%s)z"__Pyx_PyUnicode_MAX_CHAR_VALUE(%s)z	iso8859-1Z255zus-asciii   Z65535i   Z1114111z%s = (%s > %s) ? %s : %s;z	%s += %s;zPyTuple_SET_ITEM(%s, %s, %s);ZJoinPyUnicodezStringTools.cz-%s = __Pyx_PyUnicode_Join(%s, %d, %s, %s); %s))r"  rr   r{   r  r  r  r   r   r   c_py_ucs4_typer   r   r:  	enumerater(  r  r   ro   r  r   r  UnicodeEncodeErrormaxro  r  rk   FormattedValueNoder   r  r@  r,  r1  r  r   r   r   r   r   r=  r*  r  )rP   r   Z	num_itemsZlist_varZulength_varZmax_char_varirt   ZulengthZmax_char_valueZis_asciiZmax_charrN   rN   rO   r(  .  sx    









z&JoinedStrNode.generate_evaluation_codeN)rR   rS   rT   r   r   r   r   r   r   r  r(  rN   rN   rN   rO   r    s   r  c               @   sL   e Zd ZddgZeZdZdZdZdddd	d
j	Z
dd Zdd Zdd ZdS )r  r   format_specTNzString formattingZPyObject_UnicodeZPyObject_ReprZPyObject_ASCIIZ__Pyx_PyNumber_IntOrLong)sradc             C   s   dS )NFrN   )rP   rN   rN   rO   r    s    zFormattedValueNode.may_be_nonec             C   s   | j j|| _ | j s| jjrN| jr,| jj n| j jj}| j jj||drN|| _| jrh| jj|j|| _| jd kr| j j|| _ | j r| j	 s| j	dkr| j jt
kr| j j  r| j S | S )N)r  r  )r   r   r  r  r   Zdefault_format_specZcan_coerce_to_pystringc_format_specrr  conversion_charr   r  )rP   rg   r  rN   rN   rO   r     s    
z FormattedValueNode.analyse_typesc       	   	   C   st  | j d k	rd| jjj rd| jjj| jj || j }|jd| j ||j| j | jf  | j	| d S | jj
 }| jjtko| jj  }| jrd}| jj
 }n
d}tj}| j}|dkr|rd }|r
| j|}|d k	std| d||f }|jjtjdd |d	7 }n2| jr(|jjtjd
d n|jjtjdd |jd| j ||||j| j | jf  | j	| d S )Nz%s = %s; %sZ__Pyx_PyObject_FormatZ__Pyx_PyObject_FormatSimpler  z(invalid conversion character found: '%s'z%s(%s)ZPyObjectFormatAndDecrefzStringTools.cZ	AndDecrefZPyObjectFormatZPyObjectFormatSimplez%s = %s(%s, %s); %s)r  r   r   re   Zconvert_to_pystringr   r   r   rr   r=  r   r   r  r  r   Zempty_unicoder  find_conversion_funcr   r   r   r   r   )	rP   r   Zconvert_func_callZvalue_resultZvalue_is_unicodeZformat_funcr  r  fnrN   rN   rO   r#    sL    



z'FormattedValueNode.generate_result_code)rR   rS   rT   r   r   r   r   r  r   r^   r  r  r   r#  rN   rN   rN   rO   r  |  s   
r  c               @   s.   e Zd ZdZejZdd Zdd Zdd Z	dS )	ParallelThreadsAvailableNodea*  
    Note: this is disabled and not a valid directive at this moment

    Implements cython.parallel.threadsavailable(). If we are called from the
    sequential part of the application, we need to call omp_get_max_threads(),
    and in the parallel part we can just call omp_get_num_threads()
    c             C   s
   d| _ | S )NT)r   )rP   rg   rN   rN   rO   r     s    z*ParallelThreadsAvailableNode.analyse_typesc             C   sR   |j d |j d| j  |j d| j  |j d |j d| j  |j d d S )Nz#ifdef _OPENMPz2if (omp_in_parallel()) %s = omp_get_max_threads();z else %s = omp_get_num_threads();z#elsez%s = 1;z#endif)r   r   )rP   r   rN   rN   rO   r#    s    


z1ParallelThreadsAvailableNode.generate_result_codec             C   s   | j S )N)r   )rP   rN   rN   rO   r     s    z#ParallelThreadsAvailableNode.resultN)
rR   rS   rT   __doc__r   
c_int_typer   r   r#  r   rN   rN   rN   rO   r    s
   	r  c               @   s.   e Zd ZdZejZdd Zdd Zdd Z	dS )	ParallelThreadIdNodez/
    Implements cython.parallel.threadid()
    c             C   s
   d| _ | S )NT)r   )rP   rg   rN   rN   rO   r     s    z"ParallelThreadIdNode.analyse_typesc             C   sB   |j d |j d| j  |j d |j d| j  |j d d S )Nz#ifdef _OPENMPz%s = omp_get_thread_num();z#elsez%s = 0;z#endif)r   r   )rP   r   rN   rN   rO   r#    s
    

z)ParallelThreadIdNode.generate_result_codec             C   s   | j S )N)r   )rP   rN   rN   rO   r     s    zParallelThreadIdNode.resultN)
rR   rS   rT   r  r   r  r   r   r#  r   rN   rN   rN   rO   r    s
   r  c               @   s$   e Zd Zdd Zdd Zdd ZdS )_IndexingBaseNodec             C   s    | j j p| j jtttttfkS )N)r   r   r   r/   r   r   r   r   )rP   rN   rN   rO   r     s    z_IndexingBaseNode.is_ephemeralc             C   s   | j j o| jj S )N)r   r	  r   r   )rP   rN   rN   rO   r	  %  s    z"_IndexingBaseNode.check_const_addrc             C   s(   | j jr| j jjr$dS n| j jr$dS dS )NFT)r   r   rI  r   rJ  )rP   rN   rN   rO   r   (  s    
z_IndexingBaseNode.is_lvalueN)rR   rS   rT   r   r	  r   rN   rN   rN   rO   r    s   r  c               @   s  e Zd Z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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' Zd(d) Zd*d+ Zd@d,d-Zd.d/ Zd0Zd1d2 Zd3d4 Zd5d6 Zd7d8 Z dAd9d:Z!d;d< Z"dBd=d>Z#dS )Cr   r   r   NTFc             C   s   | j j| jj | _d S )N)r   rp   r   )rP   rN   rN   rO   r   H  s    z#IndexNode.calculate_constant_resultc             C   sR   | j j|}| jj|}y|| S  tk
rL } z| j| W Y d d }~X nX d S )N)r   r   r   	Exceptionr   )rP   r   r   r   r   rN   rN   rO   r   K  s    zIndexNode.compile_time_valuec             C   s.   | j }|j o,| jj o,|jo,|jjp,|jjS )N)r   r  r   r   rJ  r   )rP   r   rN   rN   rO   r  S  s    zIndexNode.is_simplec             C   sF   | j j}|r<|jrdS t| jtr<|tttt	t
ttfkr<dS tj| S )NF)r   r   r$  ro   r   	SliceNoder   r   r   r   r/   r   r   r   r  )rP   rK  rN   rN   rO   r  X  s    
zIndexNode.may_be_nonec             C   s   d S )NrN   )rP   rg   rN   rN   rO   r   d  s    z$IndexNode.analyse_target_declarationc             C   s  | j j|}|r|js|jrX| jjr0| jj}n| jg}tj| j	|d d}|j
||dS | jjsh| jjrddlm} |j|j | jjr| jgn
t| jj}tj||j||S |js| jj|}|d k	r yt|}W n ttfk
r   Y nX tj||S t| j	d d S )N)rr   positional_argskeyword_args)rK  r%   )rE  z*Array size must be a compile time constant)r   r   r   python_type_constructor_namer   ry   r   r   ZTemplatedTypeNoderr   analyser   rD  rE  r   view_utility_coder   r   MemoryViewSliceTypeget_axes_specsre   r   r  r   r   
CArrayTyper   )rP   rg   rK  Ztemplate_valuesZ	type_noderE  axesr   rN   rN   rO   r   g  s4    

zIndexNode.analyse_as_typec             C   sF   g }| }x8|j r@|jj|}|r8|jr8|jr8|j|j |j}q
W |S )N)r  r   r   r  Zmodifier_namer   r   )rP   rg   r  Zmodifier_nodeZmodifier_typerN   rN   rO   analyse_pytyping_modifiers  s    

z$IndexNode.analyse_pytyping_modifiersc             C   s   | j j|| jj| S )N)r   r   r   )rP   rg   rN   rN   rO   r     s    zIndexNode.type_dependenciesc             C   s  | j j|}| jjrN|jrtS |jr(tS |tttt	t
tfkr@|S |jrJ|S tS | jj|}|rd|jsrt| jtr|tkrtjS |tkr|S |t	krtjS t| j trtS |tt
fkrt|| j | j|d}|d k	r|S n|js|j r|jS |jrTt| jtrT| jj r| jj}|dk r*||j7 }d|  ko@|jk n  r|j| S n>|jr|jdkrh|jdkrz|jS tj |j|j!dd  S | jj"r|jr|}xB| jj#D ]2}|jsP t$| j%t&| j j%|d|dj|}qW |S |j'r<G dd d}|| j%|d|| j%|dg}	|j(d	|	}
|
d k	r<|
j)j*S t+|rjt+|rj| j|f}t,t-||gS |ttfkr||S tS d S )
N)r   r   r%   )r   )r   r   c               @   s   e Zd Zdd ZdS )z)IndexNode.infer_type.<locals>.FakeOperandc             [   s   | j j| d S )N)__dict__update)rP   r  rN   rN   rO   r    s    z2IndexNode.infer_type.<locals>.FakeOperand.__init__N)rR   rS   rT   r  rN   rN   rN   rO   FakeOperand  s   r  )rr   r   z[]).r   rv   r   r   r$  r   r%  r   r   r   r   r   r   r   r\  ro   r   r   r  c_uchar_typer  r   rJ  r   rK  r  r~   rp   ra  r  ndimrY  r  r  ry   r   r   rr   r   r   lookup_operatorr   r  r9   rE   r?   )rP   rg   rK  
index_typer  r   r  r  r  operandsZ
index_funcZindex_with_typerN   rN   rO   rv     s|    



zIndexNode.infer_typec             C   s   | j |ddS )NT)getting)analyse_base_and_index_types)rP   rg   rN   rN   rO   r     s    zIndexNode.analyse_typesc             C   sJ   | j |dd}|jjr"t| jd || krF|j  rFt| jd|j  |S )NT)settingzAssignment to const dereferencez%Assignment to non-lvalue of type '%s')r  r   r  r   rr   r   )rP   rg   rt   rN   rN   rO   r     s    zIndexNode.analyse_target_typesc       	      C   s  |r| j j|| _ | j jjr(tj| _| S | jj}|jd s\|rRt	| jj
| jj n
t	| j | rt| jtrtj| jjr| jj|| _| j jj}| rt| j ts|r| j jjs| j jjp| j jj r| j j|| _ | j||}|d k	r|S |j| _| j j}|js~| jj|| _| jj| _| jjr4| jj| _|jr~|rTt| jddd n| jj dkrh| j S | j j|| _ | j j}|j!r| j"||||S |js|jr| j#||S |j$r| j%||S |jr| j&|S |j'r| j(|||S t)| jd|  tj| _| S d S )	N
wraparoundz%cannot assign to Unicode string indexr%   )rn   r   z'Attempting to index non-array type '%s'rl  )r   rl  )*r   r   r   rU  r   r,   r   r   r_   ru   r   r   ro   r   r   Zlong_literalr   rr  r   r  r$  rJ  r   analyse_as_buffer_operationr   r   original_index_typer   rI  r  r   rr   rp   re   analyse_as_pyobjectanalyse_as_c_arrayr   analyse_as_cppanalyse_as_c_functionr  analyse_as_c_tupler   )	rP   rg   r  r  analyse_baser   Zis_memslicereplacement_noderK  rN   rN   rO   r    s`    


 
 



z&IndexNode.analyse_base_and_index_typesc             C   s  | j j}| jjjr@|tk	r@t| jddd | jj|| _d| _n| jjj	r|tk	r|r|j
d  r|tttfkr| jjj s|j
d  st| jtr| jj r| jjdkrd| _nd| _| jjtj|j|| _| jj| n| jj|| _d| _| jjj	r|tkrtj| _n| jjj	rB|tkrB|r8tj| _ntj| _n|rf|ttttttfkrf|| _nrd }|ttfkr| jjj	rt|| j | j|d}|tttfkr| j j d| _ |d ks|j! rt"| _n|| _| j#|| | S )	NzItem lookup of unicode character codes now always converts to a Unicode string. Use an explicit C integer cast to get back the previous integer lookup behaviour.r%   )rn   boundscheckr  r   )r   z&'NoneType' object is not subscriptable)$r   r   r   r  r   r   rr   rr  r   r\  r_   r   r   r   signedro   r   r~   rp   rQ  r   r   r   r  create_to_py_utility_coder   r  r  r  r   r   r   r  re   r   wrap_in_nonecheck_node)rP   rg   r   r  r  rK  r  rN   rN   rO   r  N  sP    


zIndexNode.analyse_as_pyobjectc             C   sr   | j j}|j| _| jjr&tj| j| _|r2|| _n<| jjjrP| jjtj	|| _n| jjj
snt| jd| jj  | S )NzInvalid index type '%s')r   r   rK  r   r   CReferenceTyper   re   rQ  r   r\  r   rr   )rP   rg   r   rK  rN   rN   rO   r    s    

zIndexNode.analyse_as_c_arrayc             C   s   | j j}|jd| j | jg}|d krNt| jd|| jjf  tj| _d| _| S |j}|j	r`|j
}|j| _|j| _| jr|sd| _t| r|jtjdd | jj|jd j|| _|j| _|r|jj rt| jd| j  | S )	Nz[]z/Indexing '%s' not supported for index type '%s'z<error>TCppExceptionConversionzCppSupport.cppr   z#Can't set non-reference result '%s')r   r   r  r   r   rr   r   r,   r  rJ  rK  r   r   r   r   r   r   r   rQ  r   r  r   )rP   rg   r  rK  ru  	func_typerN   rN   rO   r    s,    zIndexNode.analyse_as_cppc             C   s   | j j}|jr| j| n| j|| _d | _|jd krJt| j	d t
| _nh| jd kr\t
| _nVt|jt| jkrt| j	dt|jt| jf  t
| _n|jtt|j| j| _| S )Nz)Can only parameterize template functions.z7Wrong number of template arguments: expected %s, got %s)r   r   r   parse_indexed_fused_cdefparse_index_as_typestype_indicesr   Z	templatesr   rr   r,   r{   r   dictr  )rP   rg   rK  rN   rN   rO   r    s     

zIndexNode.analyse_as_c_functionc             C   s   | j j}t| jtr| jj r| jj}|j |  ko>|jk n  rd|dk rV||j7 }|j| | _nt	| j
d||f  tj| _| S | j j|| _ | j|||ddS d S )Nr   zIndex %s out of bounds for '%s'F)r  r  r  )r   r   ro   r   r   r~   rp   ra  r  r   rr   r   r,   rr  r  )rP   rg   r  r  rK  r   rN   rN   rO   r    s    
zIndexNode.analyse_as_c_tuplec                s  t | jtr| jj}n| jg}| j}|j}d}|jrddlm} |j	rh|j
|}|dk	rh|j}|j}|}|j||j\}	}}
|	rt| j||d}nt| j||d}n|js|jr|jst||jkrd} fdd|D }|jrJtdd	 |D }|r\x\t|D ]<\}}|jrt|j|j|j|jd
}|j }|||< qW ntdd	 |D }|rt| j||d}t | jt st|dk	r|j |}|S )zI
        Analyse buffer indexing and memoryview indexing/slicing
        Nr%   )rE  )indicesr   Tc                s   g | ]}|j  qS rN   )r   )rW   r   )rg   rN   rO   r     s    z9IndexNode.analyse_as_buffer_operation.<locals>.<listcomp>c             s   s$   | ]}|j jp|jp|j jV  qd S )N)r   r\  r   r9   )rW   r   rN   rN   rO   rZ     s   z8IndexNode.analyse_as_buffer_operation.<locals>.<genexpr>)r   r   r   c             s   s   | ]}|j jV  qd S )N)r   r\  )rW   r   rN   rN   rO   rZ      s    )ro   r   rn  r   r   r   r   rD  rE  r  merged_indicesunellipsifyr  MemoryViewSliceNoderr   MemoryViewIndexNoder-  r9   r{   allr  r   SliceIntNoder   r   r   r   BufferIndexNode	CloneNoder   )rP   rg   r  r
  r   rK  r  rE  r  have_slicesnewaxesr  Zdo_replacementr  r   rN   )rg   rO   r    sN    




z%IndexNode.analyse_as_buffer_operationc             C   s.   |j d  s| jj  rd S | jjd| _d S )N	nonecheckz&'NoneType' object is not subscriptable)r_   r   r  r  )rP   rg   r  rN   rN   rO   r  
  s    z IndexNode.wrap_in_nonecheck_nodec             C   sd   t | jtr| jj}n| jg}g }x<|D ]4}|j|j| |d d kr(|rXt|jd d S q(W |S )Nr%   znot parsable as a typerl  )ro   r   rn  r   r   r   r   rr   )rP   rg   requiredr
  r  r   rN   rN   rO   r    s    

zIndexNode.parse_index_as_typesc                sZ  t j| _d| _| jj}g }| jjs*| jjr:|j| jj	 n*t
| jtrdx| jjD ]}|j|j	 qPW | j|dd}|dkr| jj|| _| jjjst| j	d n<| jjj | j_| _| jj | j_| _d| j_d| _d| j_d| _dS x"t|D ]\}}|j|||< qW |j }t|t|kr0t| j	dS t|t|k r^|t| }	t| j	d|	 S xVt|||D ]F\}
 }t fdd	|jD st|
d
S  dks jrldS qlW tt||}|j|}|jrt| j	d nrxp| jjj D ]X}|j |r|| _| jjr*|j| _d| _| jj!| _!d| jj_|| j_|j| j_P qW t"ddS )aK  
        Interpret fused_cdef_func[specific_type1, ...]

        Note that if this method is called, we are an indexed cdef function
        with fused argument types, and this IndexNode will be replaced by the
        NameNode with specific entry just after analysis of expressions by
        AnalyseExpressionsTransform.
        TF)r  Nz)Can only index fused functions with typeszToo many types specifiedzHNot enough types specified to specialize the function, %s is still fusedc                s   g | ]} j |qS rN   )rM  )rW   rX   )specific_typerN   rO   r   U  s    z6IndexNode.parse_indexed_fused_cdef.<locals>.<listcomp>zType not in fused typez6Index operation makes function only partially specificz!Couldn't find the right signature)#r   r,   r   is_fused_indexr   r   r   r  r   rr   ro   rn  r   r  r   r   r  r   r   rN  r  Zspecialize_fusedZget_fused_typesr{   r  r`   typesrU  r	  r   r   rL  rM  rs  r   )rP   rg   rK  Z	positionsre  Zspecific_typesr  r   Zfused_typesrX   rr   Z
fused_typer   rj  rN   )r  rO   r    sl    	







z"IndexNode.parse_indexed_fused_cdefzIndexing Python objectc             C   s  | j jtttfkr^| j jtkr$d}q| j jtkr6d}q| j jtkrHd}qdstd| j j n| j jjrd| j j djdd	 | j	D f S | j jj
r| jj}|d
k r|| j jj7 }d| j j |f S | jjs| jjr| j| j jkrt| jd d S d}|| j j | jj f S )NzPyList_GET_ITEM(%s, %s)zPyTuple_GET_ITEM(%s, %s)z0((unsigned char)(PyByteArray_AS_STRING(%s)[%s]))Fz$unexpected base type in indexing: %sz%s<%s>,c             S   s   g | ]}|j  qS rN   )r  )rW   paramrN   rN   rO   r     s    z3IndexNode.calculate_result_code.<locals>.<listcomp>r   z%s.f%szInvalid use of pointer slicez(%s[%s]))r   r   r   r   r   r   r   r   joinr  r  r   rp   ra  rJ  r   r   rr   )rP   
index_coder   rN   rN   rO   r   z  s,    

zIndexNode.calculate_result_codec             C   s   | j jjr| jjtk}t|jjd oH| jj	oHt
| j jtoF| j jdk }t|jjd }d| jj | jj	rpdprd| jj|||f S dS d S )Nr  r   r  z, %s, %d, %s, %d, %d, %dr%   rD  )r   r   r\  r   r   r   r   r_   r  r   ro   rp   r#   r  Zto_py_function)rP   r   Zis_listr  r  rN   rN   rO   extra_index_params  s    
zIndexNode.extra_index_paramsc          
   C   s|  | j s
d S d }d }| jjrd}| jjjr^| jjtkr:d}n| jjtkrLd}nd}tj	dd}np| jjt
kr|d}tj	dd}nR| jjtkr| jjttfkrd	}tj	dd}n$d
}|jjtj	dd tj	dd}n| jjo| jjtkr
| jjjstd}d}tj	dd}nv| jjtkrL| jjjs(t| jjs6td}d}tj	dd}n4| jjjo\| jsdstd| j| jj| jf |d k	r|jj| | jjjr| jj }n
| jj }| jjjr| jrt|| jd| j | jj | jj f | jjr| j nd | j| j nR|dkr dnd| }|jd| j || jj || j||j|| j  | jf  | jjrx| j| d S )Nr  Z__Pyx_GetItemInt_ListZ__Pyx_GetItemInt_TupleZ__Pyx_GetItemIntZ
GetItemIntzObjectHandling.cZ__Pyx_PyDict_GetItemZDictGetItemZ__Pyx_PyObject_Dict_GetItemZ__Pyx_PyObject_GetItemZObjectGetItemZ__Pyx_GetItemInt_Unicodez(Py_UCS4)-1ZGetItemIntUnicodezStringTools.cZ__Pyx_GetItemInt_ByteArrayz-1ZGetItemIntByteArrayFz5unexpected type %s and base type %s for indexing (%s)z%s = %s[%s];z!%sz	%%s == %sz%s = %s(%s, %s%s); %s) r   r   re   r   r\  r   r   r   r   r   r   r   r   r   r   r   r   r  r   r   r   r   rr   r   r   r   r   r  r   r  r   r=  )rP   r   rC  Zerror_valueru  r  Zerror_checkrN   rN   rO   r#    sv    




zIndexNode.generate_result_codec          	   C   s   | j jjrT| jjtkr0|jjtjdd d}n|jjtjdd d}| j j	 }n | j j
 }| jjtkrpd}nd}|j|jd	|| jj
 ||| j|f | j d S )
NZSetItemIntByteArrayzStringTools.cZ__Pyx_SetItemInt_ByteArrayZ
SetItemIntzObjectHandling.cZ__Pyx_SetItemIntrM  ZPyObject_SetItemz%s(%s, %s, %s%s))r   r   r\  r   r   r   r   r   r   r   r   r   r   r  r  rr   )rP   
value_coder   ru  r  rN   rN   rO   generate_setitem_code  s*    

	zIndexNode.generate_setitem_codec          	   C   s  | j | | jjr$| j|j | n| jjtkrJ| j||}| j|| n| jjjr| j	r| j	dkr|r|r| j
|krt|| j| j| j |j | j
|| j qt|| jd| j |j f | jjr| j nd | j
| j n|jd| j |j f  | j| | j| |j| |j| d S )Nr   z%s = %s;)r!  r   re   r   r   r   r   _check_byte_valuer   r   r   r   rr   r   r  r   r   r&  r'  r+  r1  )rP   r|   r   r-  r   r   r  rN   rN   rO   r.    s*    



z"IndexNode.generate_assignment_codec             C   s  |j jstt|j |j }|j r`d|j  ko:dk n  rD|S d}t|jd|j dd n|j t	j
k}| jsg }|js|j jr|jd|  |js|jo|j t	j
t	jt	jfk r|jd|  |r|jd	d
j|  |jd|j| j  |jd |r
d| }|S )Nr      Tz9value outside of range(0, 256) when assigning to byte: %sr%   )rn   z%s < 0z%s > 255zif (unlikely(%s)) {z || zFPyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)"); %sr   z((unsigned char)%s))r   r\  r   r  r   r~   rp   r   rr   r   r  r   r   r   r   r   r   c_schar_typer   r  r   )rP   r   r|   r  Z
needs_castZ
conditionsrN   rN   rO   r!  /  s:    


zIndexNode._check_byte_valuec             C   s   | j | | jjjr8d}| jj }|jjtjdd n | jj	 }| j
jtkrTd}nd}|j|jd|| j
j	 || j|f | j | j| | j| d S )NZ__Pyx_DelItemIntZ
DelItemIntzObjectHandling.cZPyDict_DelItemZPyObject_DelItemz%s(%s, %s%s))r!  r   r   r\  r   r   r   r   r   r   r   r   r   r  r  rr   r&  r'  )rP   r   r/  ru  r  rN   rN   rO   r0  S  s&    





z IndexNode.generate_deletion_code)FFT)T)FNN)F)$rR   rS   rT   r   r  r  r  r   r   r  r  r   r   r  r   rv   r   r   r  r  r  r  r  r  r  r  r  r  r   r   r  r#  r   r.  r!  r0  rN   rN   rN   rO   r   8  sF   
 d 
G:5
[H! 
 $r   c                   s   e Zd ZdZddgZdZdZf 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 Zdd Zdd Zd$ddZd%ddZdd  Z fd!d"Z  ZS )&r  z
    Indexing of buffers and memoryviews. This node is created during type
    analysis from IndexNode and replaces it.

    Attributes:
        base - base node being indexed
        indices - list of indexing expressions
    r   r
  TFc             C   s   | j |dd d S )NF)r  )r   )rP   rg   rN   rN   rO   r     s    z$BufferIndexNode.analyse_target_typesc             C   s   | j j r.t| j j r.t| jd t| _| S |sh| j jjjsLt| jd nd| _	| j jj
rhd| j jj_	d| _| j|| | j| | S )zz
        Analyse types for buffer indexing only. Overridden by memoryview
        indexing and slicing subclasses
        zCan only index buffer variableszWriting to readonly bufferTz&'NoneType' object is not subscriptable)r   r   r9   r   r   rr   r,   r   writablerV  r-  Z
buffer_auxnone_error_messageanalyse_buffer_indexr  )rP   rg   r  rN   rN   rO   r     s    

zBufferIndexNode.analyse_typesc             C   st   t | jjr2dd | jD }tt| jj|| _n| jj|| _| jjj| _| jj| _|rp| jj	sj| jj rpd| _
d S )Nc             S   s   g | ]}||j fqS rN   )r   )rW   idxrN   rN   rO   r     s    z8BufferIndexNode.analyse_buffer_index.<locals>.<listcomp>T)r9   r   r   r
  rE   r?   r   rY  buffer_typere   r   )rP   rg   r  Zindex_with_type_listrN   rN   rO   r&    s    
z$BufferIndexNode.analyse_buffer_indexc             C   s   dS )zk
        Called by IndexNode when this node is assigned to,
        with the rhs of the assignment
        NrN   )rP   r|   rN   rN   rO   analyse_assignment  s    z"BufferIndexNode.analyse_assignmentc             C   s0   |j d  s| jj  rd S | jj| j| _d S )Nr  )r_   r   r  r  r%  )rP   rg   rN   rN   rO   r    s    z&BufferIndexNode.wrap_in_nonecheck_nodec             C   s*   | j s| jr&| jjr&t| jd t| _d S )Nz2Cannot access buffer with object dtype without gil)r  r  r   re   r   rr   r,   )rP   rg   rN   rN   rO   r    s    zBufferIndexNode.nogil_checkc             C   s
   d| j  S )Nz(*%s))buffer_ptr_code)rP   rN   rN   rO   r     s    z%BufferIndexNode.calculate_result_codec             C   s    | j }| j jr|j}|jj|S )N)r   is_nonecheckre  r   Z	get_entry)rP   r   rN   rN   rO   buffer_entry  s    zBufferIndexNode.buffer_entryc             C   sD   |j jtj|j|jjrtjntjdd}|jd||j	 f  |S )NF)r  z%s = %s;)
r  r  r   r  r   r   Zc_ssize_t_typec_size_t_typer   r   )rP   r   ivarretrN   rN   rO   get_index_in_temp  s    z!BufferIndexNode.get_index_in_tempc                s   j r.jsjr. jjd r.tjddd  fddjD  _}ddl	m
} j }|jjrp|jj}n
|jd }||j|d	d jD | jjj |j d
fS )z8
        ndarray[1, 2, 3] and memslice[1, 2, 3]
        r  z(Use boundscheck(False) for faster accessr%   )rn   c                s   g | ]}j  |qS rN   )r0  )rW   r.  )r   rP   rN   rO   r     s    z6BufferIndexNode.buffer_lookup_code.<locals>.<listcomp>)r+  negative_indicesc             S   s   g | ]}|j jqS rN   )r   r   )rW   r.  rN   rN   rO   r     s    )r   Zindex_signedsZindex_cnamesr_   rr   r   r1  r  )r  r  r  r   r_   r   rr   r
  index_tempsrD  r+  r,  r   r-  r1  Zbuffer_defaultsZput_buffer_lookup_code)rP   r   r2  r+  r,  r1  rN   )r   rP   rO   buffer_lookup_code  s$    

z"BufferIndexNode.buffer_lookup_codec             C   sB   | j | | j|| | j| | j| |j| |j| d S )N)r!  generate_buffer_setitem_coder&  r'  r+  r1  )rP   r|   r   r-  rN   rN   rO   r.    s    



z(BufferIndexNode.generate_assignment_coderD  c       
      C   sL  | j j}t|rt|jr|jjtt| j jdd}|jd|  |jd||| j j	 f  |jd|t
| j||j	 f  |jj| d S | j|\}}| jjjr0|jj|jdd}|j }	|jd||f  |jd| | jj |jd|	|f  |jd	|||	f  |jd| | jj |jj| n|jd	|||j f  d S )
NF)r  z__Pyx_call_destructor(%s);znew (&%s) decltype(%s){%s};z%s%s %s= %s;z%s = %s;z*%sz%__Pyx_INCREF(%s); __Pyx_XDECREF(*%s);z*%s %s= %s;)r   r   r9   r7   r  r  rE   rA   r   r   r>   r
  r  r3  r(  rY  re   Zbuf_ptr_typer   r>  rA  )
rP   r|   r   oprK  rs  r,  Zptrexprptrr   rN   rN   rO   r4    s2    	
z,BufferIndexNode.generate_buffer_setitem_codec             C   s   t | jjrH| j }|jd|  |jd||| jj t| jf  d S | j|\}| _	| jj
r| j }|jd|| j	f  |jd||f  |jd|  d S )Nz__Pyx_call_destructor(%s);znew (&%s) decltype(%s){%s%s};z%s = (PyObject *) *%s;z'if (unlikely(%s == NULL)) %s = Py_None;z__Pyx_INCREF((PyObject*)%s);)r9   r   r   r   r   r   r>   r
  r3  r*  re   )rP   r   resr,  rN   rN   rO   r#    s    z$BufferIndexNode.generate_result_codec                s6   x| j D ]}|jj| qW f | _ tt| j| d S )N)r2  r  r  rJ   r  r'  )rP   r   temp)rM   rN   rO   r'  .  s    z"BufferIndexNode.free_subexpr_temps)T)F)rD  )rR   rS   rT   r  r   r  rV  r2  r   r   r&  r)  r  r  r   r,  r0  r3  r.  r4  r#  r'  rU   rN   rN   )rM   rO   r  l  s&   
	

*r  c               @   s6   e Zd ZdZdZdddZdd Zdd Zd	d
 ZdS )r  TFc             C   s^  ddl m} t|| _| j}|j|| jjj\}}}|sZd| _	| jj
sN| jjrZd| jjj_	| opt|| jjjk| _g }tj}g }	t|t| | jjjkrt| _t|| jjj jd| jj  | S d}
xPt|d d  D ]:\}}|j|}|jrd| _|	j| |jd q| jjj|
 \}}|
d7 }
|jrd| _|jjrV|j||f n|j|df xdD ]:}t||}|jsj|j||}t||| |	j| qjW q|jjs|jj r|jj rt!|jd| d| _"|j||}|||< |	j| qt| _t|jd|j  | S qW | j"o*| j | _"|	| _|| _#|j$| _$| j%||| | j&| | S )Nr%   )rE  Tz&Too many indices specified for type %sr   directstridedr   r   r   z/Index should be typed for more efficient accessz/Invalid index for memoryview specified, type %s)r9  r:  )r   r   r   )'rD  rE  r=   Zis_pythran_moder
  r  r   r   r  rV  r   r  r   r{   Zmemslice_indexr   r   r,   r   rr   r  r   rZ  r  r   r  r   r   r   rQ  setattrr\  re   r'   r  original_indicesr   analyse_operationr  )rP   rg   r  rE  r
  r  r  r  r  new_indicesZaxis_idxr  r   accesspackingattrr   rN   rN   rO   r   :  sn    








z!MemoryViewIndexNode.analyse_typesc             C   s   d| _ | j|| d S )Nz"Cannot index None memoryview slice)r%  r&  )rP   rg   r  r  rN   rN   rO   r=    s    z%MemoryViewIndexNode.analyse_operationc             C   s(   | j jr$| }|js|jr$d|_d|_dS )z
        Support broadcasting for slice assignment.
        E.g.
            m_2d[...] = m_1d  # or,
            m_1d[...] = m_2d  # if the leading dimension has extent 1
        TN)r   r   rW  )rP   r|   lhsrN   rN   rO   analyse_broadcast_operation  s
    z/MemoryViewIndexNode.analyse_broadcast_operationc             C   s   | j |}|r|j|_|S | S )N)r)  rX  )rP   r|   rB  rN   rN   rO   $analyse_as_memview_scalar_assignment  s
    
z8MemoryViewIndexNode.analyse_as_memview_scalar_assignmentN)T)	rR   rS   rT   r  r  r   r=  rC  rD  rN   rN   rN   rO   r  5  s   
Or  c               @   sb   e Zd ZdZdZdZdZdZdd Zdd Z	dd Z
d	d
 Zdd Zdd Zdd ZdddZdS )r  TFc             C   s*   t dd | jD | _| jr&| jj| _dS )z@Slicing operations needing no evaluation, i.e. m[...] or m[:, :]c             s   s,   | ]$}|j o"|jjo"|jjo"|jjV  qd S )N)r   r   rZ  r   r   )rW   r   rN   rN   rO   rZ     s   z<MemoryViewSliceNode.analyse_ellipsis_noop.<locals>.<genexpr>N)r  r
  is_ellipsis_noopr   r   )rP   rg   r  rN   rN   rO   analyse_ellipsis_noop  s
    z)MemoryViewSliceNode.analyse_ellipsis_noopc             C   s   ddl m} |sd| _d| _nd| _| j|| | jr:d S d | _d| _d| _|j	| j
|sdt| _d S tj| jjj|| _| jj p| jj s| jj|| _d S )Nr%   )rE  Tz&Cannot assign to None memoryview slicez"Cannot slice None memoryview slice)rD  rE  rW  r%  rF  rE  r   r   r  Zvalidate_axesrr   r,   r   r   r  r   rY  r  r
  r  )rP   rg   r  r  rE  rN   rN   rO   r=    s"    z%MemoryViewSliceNode.analyse_operationc             C   s>   |j j r.| j jj|j s"|j jr.t| j| S t| j| S d S )N)r   r   rY  rc  re   MemoryCopyScalarrr   MemoryCopySlice)rP   r|   rN   rN   rO   r)    s
    
z&MemoryViewSliceNode.analyse_assignmentc             C   s   |sdS | j dd }|dd }xft| j D ]X\}}|jrz|jjrt|jjrt|jjrt|d ||< |jd |sx|S qdS q.|jj	s.dS q.W |rt
|t
| | jjjkrdS ||7 }|S )a  Return a new list of indices/slices with 'indices' merged into the current ones
        according to slicing rules.
        Is used to implement "view[i][j]" => "view[i, j]".
        Return None if the indices cannot (easily) be merged at compile time.
        Nr   )r<  r  r   r   rZ  r   r   r   r   r\  r{   r   r  )rP   r
  r>  r  r  rN   rN   rO   r    s&    
z"MemoryViewSliceNode.merged_indicesc             C   s"   | j r| jj p| jj S | j S )N)rE  r   r  r
  )rP   rN   rN   rO   r    s    zMemoryViewSliceNode.is_simplec             C   s
   | j j S )z3This is called in case this is a no-op slicing node)r   r   )rP   rN   rN   rO   r     s    z)MemoryViewSliceNode.calculate_result_codec          	   C   s   | j r
d S | j }| j }d}t| j}xX| jD ]N}|jrvd}|jjsPt	||_|j
jsbt	||_
|jjs~t	||_q0t	| q0W t| st|j|| j| j | j|||jjd d S )NFT)r  r  r_   )rE  r,  r  iterr
  r<  r   r   rZ  nextr   r   r   r   Zgenerate_buffer_slice_coder   r   r   r_   )rP   r   r,  r  r  r  r   rN   rN   rO   r#    s*    


z(MemoryViewSliceNode.generate_result_codec             C   sp   | j r| j| n
| j| | jr0| j|| n| j|| | j rN| j| n
| j| |j| |j| d S )N)	rE  r!  r(  is_memview_scalar_assignmentZ+generate_memoryviewslice_assign_scalar_codeZ&generate_memoryviewslice_setslice_coder&  r+  r1  )rP   r|   r   r-  rN   rN   rO   r.    s    


z,MemoryViewSliceNode.generate_assignment_codeN)F)rR   rS   rT   r  rE  rK  r  rW  rF  r=  r)  r  r  r   r#  r.  rN   rN   rN   rO   r    s   
	r  c                   s0   e Zd ZdZdgZ fddZdddZ  ZS )	MemoryCopyNodeze
    Wraps a memoryview slice for slice assignment.

        dst: destination mememoryview slice
    dstc                s"   t t| j| || _|j| _d S )N)rJ   rL  r  rM  r   )rP   rr   rM  )rM   rN   rO   r  <  s    zMemoryCopyNode.__init__Fc             C   sH   | j j| | j|| | j j| | j j| |j| |j| d S )N)rM  r(  _generate_assignment_coder+  r1  )rP   r|   r   r-  rN   rN   rO   r.  A  s    
z'MemoryCopyNode.generate_assignment_code)F)rR   rS   rT   r  r   r  r.  rU   rN   rN   )rM   rO   rL  3  s   rL  c               @   s    e Zd ZdZdZdZdd ZdS )rH  z
    Copy the contents of slice src to slice dst. Does not support indirect
    slices.

        memslice1[...] = memslice2
        memslice1[:] = memslice2
    TZ__pyx_memoryview_copy_contentsc          	   C   sb   | j }|jj|j |jj|j |j|jd| j|j |j |jj|jj|jj	j
f |j d S )Nz%s(%s, %s, %d, %d, %d))rM  r   assert_direct_dimsrr   r   r  copy_slice_cnamer   r  rY  re   )rP   ri  r   rM  rN   rN   rO   rN  V  s    z)MemoryCopySlice._generate_assignment_codeN)rR   rS   rT   r  rX  rP  rN  rN   rN   rN   rO   rH  J  s   rH  c                   s(   e Zd ZdZ fddZdd Z  ZS )rG  z
    Assign a scalar to a slice. dst must be simple, scalar will be assigned
    to a correct type and not just something assignable.

        memslice1[...] = 0.0
        memslice1[:] = 0.0
    c                s    t t| j|| |jj| _d S )N)rJ   rG  r  r   rY  )rP   rr   rM  )rM   rN   rO   r  m  s    zMemoryCopyScalar.__init__c             C   sP  ddl m} | jjj| jj | jjj}|jd}| jjjd}|j  |j	d||j
 f  | jj sr| jj r~| jj
 }n|j	d|| jj
 f  d}d}| jj}	x4|	D ],}
t|
tr|
jjo|
jjo|
jj rd}qW |j| jj|| jjj||d	}|j }|jr|j	d
|  |j	d||f  |jr<|j	d |j  |j  d S )Nr%   )rE  rD  z%s __pyx_temp_scalar = %s;z%s __pyx_temp_slice = %s;Z__pyx_temp_sliceFT)force_stridedzPy_DECREF(*(PyObject **) %s);z!*((%s *) %s) = __pyx_temp_scalar;zPy_INCREF(__pyx_temp_scalar);)rD  rE  rM  r   rO  rr   rY  r   Zbegin_blockr   r   r
  r  r<  ro   r  r   rZ  r   r   Z
slice_iterr  Zstart_loopsre   Z	end_loopsZ	end_block)rP   Zscalarr   rE  rY  Z	type_declZ
slice_declZdst_temprQ  r
  r'  Zslice_iter_objprN   rN   rO   rN  q  s:    





z*MemoryCopyScalar._generate_assignment_code)rR   rS   rT   r  r  rN  rU   rN   rN   )rM   rO   rG  d  s   rG  c                   s   e Zd Zddddg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d7ddZdd Z fddZdZejddd d!id"Zejddd d#id"Z fd$d%Zd&d' Zd8d(d)Zd9d*d+Zd,d- Zd.d/ Zd0d1 Zd2d3 Zd4d5 Z  ZS ):SliceIndexNoder   r   r   sliceFNc             C   s^   | j j|}|js|jrtS |jr&tS |ttttt	t
tfkr@|S |jsL|jrZtj|jd S tS )N)r   rv   r$  r   r   r%  r   r   r   r/   r   r   rJ  r   r   Zc_array_typerK  r   )rP   rg   rK  rN   rN   rO   rv     s    
zSliceIndexNode.infer_typer   c             C   s6   |t k	r*| jr*| jj r&|| jj7 }nt }| jj|S )N)r   r   r~   rp   r   r   )rP   r   rN   rN   rO   r     s
    
z"SliceIndexNode.inferable_item_nodec             C   s8   | j j}|r.|jrdS |ttttttfkr.dS t	j
| S )NF)r   r   r$  r   r   r   r/   r   r   r   r  )rP   rK  rN   rN   rO   r    s    zSliceIndexNode.may_be_nonec             C   sF   | j d krd }n| j j}| jd kr(d }n| jj}| jj|| | _d S )N)r   rp   r   r   )rP   r   r   rN   rN   rO   r     s    

z(SliceIndexNode.calculate_constant_resultc             C   s   | j j|}| jd krd}n| jj|}| jd kr8d }n| jj|}y||| S  tk
r| } z| j| W Y d d }~X nX d S )Nr   )r   r   r   r   r  r   )rP   r   r   r   r   r   rN   rN   rO   r     s    

z!SliceIndexNode.compile_time_valuec             C   s   d S )NrN   )rP   rg   rN   rN   rO   r     s    z)SliceIndexNode.analyse_target_declarationc             C   s    | j |dd}|jjrt|_|S )NF)r  )r   r   re   r   )rP   rg   rt   rN   rN   rO   r     s    z#SliceIndexNode.analyse_target_typesTc                st  | j j|| _ | j jjs,| j jjs,| j jjrzt| j}t| j| j	pD|| j
pL||d}t| j|| j d}|j||| ddS | j	r| j	j|| _	| j
r| j
j|| _
|jd st| j	| j
 | j j}|jr| r| j	 r| j
 r|| _ntj|j| _nh|js|jrt|| _nL|jr"t| _n<|jr2|| _n,|jrJtj|j| _n| j j|| _ t| _|jrz|| _| j jd| _ | jtkr| j	 s| j	jrj| j
 s| j
jrjt| j}t| jtj| j	p|tj| j
p||dj|| _ nztj!  fdd}| j	r6| j	jj"r&|| j	d	|| _	| j	j# || _	| j
rj| j
jj"rZ|| j
d
|| _
| j
j# || _
d| _$| S )N)r   r   r   )r   r   F)r  r  r  r  z&'NoneType' object is not subscriptablec          
      sz   ddl m}m} || }t| jt| j ||j r8t|ntd|j	 |t
| j|dt| jdj|dj|}|||S )Nr%   )EvalWithTempExprNodeResultRefNode)r   r   rp   is)operand1r
   operand2)true_val	false_valtest)	UtilNodesrU  rV  CondExprNoderr   r   r  r  r   rQ  PrimaryCmpNoder[  r   analyse_result_type)rt   default_valuerg   rU  rV  Znode_refZnew_expr)c_intrN   rO   
allow_none+  s$    

z0SliceIndexNode.analyse_types.<locals>.allow_noner  r  r%   )%r   r   r   r-  r9   r   r[  rr   r  r   r   r   r  r_   ru   r   r   r  rK  r$  is_cpp_stringrm   r%  r   rJ  rr  r   r
  r  r   copydeepcopyrT  r   re   rQ  r   )rP   rg   r  	none_noder   r   rK  rc  rN   )rb  rO   r     sr    



zSliceIndexNode.analyse_typesc             C   sn   | j j|}|rj| j rj| j rjddlm} |j|j t| j	}t
| j	|||d}tj||j||gS d S )Nr%   )rE  )r   r   r   )r   r   r   r   rD  rE  r   r  r[  rr   r  r   r  r  )rP   rg   rK  rE  rg  Z
slice_noderN   rN   rO   r   M  s    
zSliceIndexNode.analyse_as_typec                s   |j | _ tt| j|S )N)r   rJ   rS  r  )rP   rg   )rM   rN   rO   r  _  s    zSliceIndexNode.nogil_checkzSlicing Python objectZSliceObjectzObjectHandling.cr?  ZGet)r  Setc                s   | j jjs| j jjrZ|ttttfkrZ|ttfkrT|jd  rTt	| j
d| j j|f  || _|jr| j jjr| j r| j r| j j||S tt| j||S )NrV   z:default encoding required for conversion from '%s' to '%s')r   r   r$  rd  r   r   r   r   r_   r   rr   r   r   r   rQ  rJ   rS  )rP   rh  rg   )rM   rN   rO   rQ  k  s    zSliceIndexNode.coerce_toc             C   s  | j jst| jd| j   d S | jj }| j }| j }| j }| jj jr| jj }| jj t	j
t	jfkrpd| }| j tkrd}n| j jj }| jd kr|jd|||||j|| jf  n&|jd|||||||j|| jf  n| jj jr| jj }| jj t	jkrd| }| jd krT|jd||||j|| jf  |jjtjdd	 n8|jd
||||||j|| jf  |jjtjdd	 n6| jj tkr|jjtjdd	 |jd|||||j|| jf  n| j tkrH|jj| j | j \}}}	}
}}}|jd|| jj |	|
|||||t|jjd |j|| jf  n~| jj tkrp|jjt jdd d}n,| jj t!kr|jjt jdd d}nd}|jd||| jj |||j|| jf  | j"| d S )Nz,Slicing is not currently supported for '%s'.z((const char*)%s)Z	ByteArrayz'%s = __Pyx_Py%s_FromString(%s + %s); %sz7%s = __Pyx_Py%s_FromStringAndSize(%s + %s, %s - %s); %sz((const Py_UNICODE*)%s)z-%s = __Pyx_PyUnicode_FromUnicode(%s + %s); %sZpyunicode_from_unicodezStringTools.cz?%s = __Pyx_PyUnicode_FromUnicodeAndLength(%s + %s, %s - %s); %sZPyUnicode_Substringz.%s = __Pyx_PyUnicode_Substring(%s, %s, %s); %szD%s = __Pyx_PyObject_GetSlice(%s, %s, %s, %s, %s, %s, %d, %d, %d); %sr  ZSliceTupleAndListzObjectHandling.cZ__Pyx_PyList_GetSliceZ__Pyx_PyTuple_GetSliceZPySequence_GetSlicez%s = %s(%s, %s, %s); %s)#r   re   r   rr   r   r   
start_code	stop_coder$  r   ra   rc   r   rf   titler   r   r   r%  c_py_unicode_ptr_typer   r   r   r   r   r   get_slice_utility_codeget_slice_configr   r   r_   r   r   r   r=  )rP   r   Zbase_resultr   ri  rj  	type_namehas_c_start
has_c_stopc_startc_stoppy_startpy_stoppy_slicecfuncrN   rN   rO   r#  {  s    





z#SliceIndexNode.generate_result_codec             C   s  | j | | jjrt|jj| j | j \}}}}	}
}}|j| jd| j	j
 |j
 ||	|
||||t|jjd f
  n|| jr| j nd}|jjr|jj}| j|| nd| j |f }|jjtjdd |jd| j	j ||j | j	j |f  | j| | j| |j| |j| d S )Nz?__Pyx_PyObject_SetSlice(%s, %s, %s, %s, %s, %s, %s, %d, %d, %d)r  r  z%s - %sIncludeStringHzStringTools.cz,memcpy(&(%s[%s]), %s, sizeof(%s[0]) * (%s));)r!  r   re   r   r   set_slice_utility_codern  r  rr   r   r   r   r_   r   ri  r   ra  generate_slice_guard_coderj  r   r   r   r   r&  r'  r+  r1  )rP   r|   r   r-  r   r   rp  rq  rr  rs  rt  ru  rv  Zstart_offsetarray_lengthrN   rN   rO   r.    s4    




z'SliceIndexNode.generate_assignment_codec       
      C   s   | j jjs t| jd| j  d S | j| |jj| j | j	 \}}}}}}}	|j
| jd| j j |||||	||t|jjd f	  | j| | j| d S )Nz=Deleting slices is only supported for Python types, not '%s'.z;__Pyx_PyObject_DelSlice(%s, %s, %s, %s, %s, %s, %d, %d, %d)r  )r   r   re   r   rr   r!  r   r   ry  rn  r  r   r   r_   r&  r'  )
rP   r   r/  rp  rq  rr  rs  rt  ru  rv  rN   rN   rO   r0    s     


z%SliceIndexNode.generate_deletion_codec             C   s   d\}}}| j r:| j jj }|r,| j j }nd| j j  }d\}}}| jrt| jjj }|rf| jj }nd| jj  }| jrd| jj  pd}|||||||fS )NFr  r  z&%s)Fr  r  )Fr  r  )r   r   re   r   r   r   rT  )rP   rp  rr  rt  rq  rs  ru  rv  rN   rN   rO   rn    s    

zSliceIndexNode.get_slice_configc       
   %   C   st  | j jjsd S | j jj}yt| }}W n tk
r@   d }Y nX d  }}| jr| jj }y<t|}|dk r|d krd||f }q||7 }n|}d }W n tk
r   Y nX | jr4| jj }y^t|}|dk r|d krd| j jj|f }n||7 }t	|t
r
||8 }nd||f }d }W n tk
r2   Y nX d }d}yt|}	W n tk
rb   d }	Y nX t	|t
}|r|dk r|	dkr
t| jd nt|r|d kr|d kr|	|kr
t| jd||f  n:|d k	r|d kr|}d||f }n|d k	r|}n|}|rp|jd||f  | jr2|j  |jd	||f  | jrT|j  |j|j| j |jd
 d S )Nr   z%s + %dz	%s - (%s)FzAssignment to empty slice.z8Assignment to slice of wrong length, expected %s, got %sz	(%s)-(%s)zif (unlikely((%s) != (%s))) {zPyErr_Format(PyExc_ValueError, "Assignment to slice of wrong length, expected %%" CYTHON_FORMAT_SSIZE_T "d, got %%" CYTHON_FORMAT_SSIZE_T "d", (Py_ssize_t)(%s), (Py_ssize_t)(%s));r   )r   r   r   ra  r  r   r   r   r   ro   r#   r   rr   r   r   r   r   r   )
rP   r   Ztarget_sizeZ
slice_sizetotal_lengthr   r   Zruntime_checkZcompile_time_checkZint_target_sizerN   rN   rO   rz  ,  s    













z(SliceIndexNode.generate_slice_guard_codec             C   s   | j r| j j S dS d S )Nr  )r   r   )rP   rN   rN   rO   ri  ~  s    
zSliceIndexNode.start_codec             C   s,   | j r| j j S | jjjr$| jjjS dS d S )Nr  )r   r   r   r   r   ra  )rP   rN   rN   rO   rj    s
    


zSliceIndexNode.stop_codec             C   s   dS )Nz<unused>rN   )rP   rN   rN   rO   r     s    z$SliceIndexNode.calculate_result_code)r   )T)FNN)F)rR   rS   rT   r   r   rT  rv   r   r  r   r   r   r   r   r   r  r   r   loadrm  ry  rQ  r#  r.  r0  rn  rz  ri  rj  r   rU   rN   rN   )rM   rO   rS    s8   	
	

`i 
!
RrS  c               @   sV   e Zd ZdddgZdZeZdZdd Zdd	 Z	d
d Z
dd ZdZdd Zdd ZdS )r  r   r   r   Tr%   c             C   s   t | jj| jj| jj| _d S )N)rT  r   rp   r   r   )rP   rN   rN   rO   r     s    z#SliceNode.calculate_constant_resultc             C   sb   | j j|}| jj|}| jj|}yt|||S  tk
r\ } z| j| W Y d d }~X nX d S )N)r   r   r   r   rT  r  r   )rP   r   r   r   r   r   rN   rN   rO   r     s    zSliceNode.compile_time_valuec             C   s   dS )NFrN   )rP   rN   rN   rO   r    s    zSliceNode.may_be_nonec             C   sp   | j j|}| jj|}| jj|}|j|| _ |j|| _|j|| _| j jrl| jjrl| jjrld| _d| _| S )NTF)r   r   r   r   rr  r   r   )rP   rg   r   r   r   rN   rN   rO   r     s    zSliceNode.analyse_typesz Constructing Python slice objectc             C   s   | j S )N)r  )rP   rN   rN   rO   r     s    zSliceNode.calculate_result_codec          	   C   s   | j rLt| j| f}|jtdd|d| _|j| j}|d kr@d S |j| j |j	d| j
 | jj | jj | jj |j| j
 | jf  | j| | j r| j| d S )NrT  r2   )cleanup_level	dedup_keyz %s = PySlice_New(%s, %s, %s); %s)r   r   r   r  r   r  r  r"  rr   r   r   r   r   r   r   r   r=  r@  )rP   r   r  rN   rN   rO   r#    s"    
zSliceNode.generate_result_codeN)rR   rS   rT   r   r   r    r   r   r   r   r  r   r   r   r#  rN   rN   rN   rO   r    s   
	r  c               @   s@   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dS )r  r   c             C   s   t | jj| jj| jj| _d S )N)rT  r   rp   r   r   )rP   rN   rN   rO   r     s    z&SliceIntNode.calculate_constant_resultc             C   sb   | j j|}| jj|}| jj|}yt|||S  tk
r\ } z| j| W Y d d }~X nX d S )N)r   r   r   r   rT  r  r   )rP   r   r   r   r   r   rN   rN   rO   r     s    zSliceIntNode.compile_time_valuec             C   s   dS )NFrN   )rP   rN   rN   rO   r    s    zSliceIntNode.may_be_nonec             C   s   | j j|| _ | jj|| _| jj|| _| j js@| j j|| _ | jjsV| jj|| _| jjsl| jj|| _| j jr| jjr| jjrd| _d| _| S )NTF)r   r   r   r   rZ  r  r   r   )rP   rg   rN   rN   rO   r     s    zSliceIntNode.analyse_typesc             C   s   d S )NrN   )rP   rN   rN   rO   r     s    z"SliceIntNode.calculate_result_codec             C   s2   x,| j | j| jfD ]}t|tr|jj  qW d S )N)r   r   r   ro   r  re  r   )rP   r   r  rN   rN   rO   r#    s    
z!SliceIntNode.generate_result_codeN)
rR   rS   rT   r   r   r   r  r   r   r#  rN   rN   rN   rO   r    s   		r  c               @   sV   e Zd Z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ZdS )CallNodeNc       	         sP  | j }|j }t|tr&tj|jS |tkrLt|dd }|d k	rL|j	pJ|}|j
rX|j}|jrt| j dd rt| dr| j jj } fdd| jD }tj||}|r|j	}|j
r|j}|jS |jS |tkr&|jo|jo|jj	r&|jj	}|jr|S |jr&|jjdkrtjS |jjtjkr&|S | j j }|rL|jsH|jrL|S tS )Nr   r   c                s   g | ]}|j  qS rN   )rv   )rW   re  )rg   rN   rO   r   !  s    z'CallNode.infer_type.<locals>.<listcomp>rq   )ru  rv   ro   r  r   r  r  r   r   r   rJ  rK  r   rm  r   all_alternativesr   
best_matchr  r   r   r	  r
  rf   r  r   #types_that_construct_their_instancer   is_struct_or_unionr   )	rP   rg   ru  r  r   alternatives	arg_types
func_entryresult_typerN   )rg   rO   rv     sF    



zCallNode.infer_typec             C   s   | j j|S )N)ru  r   )rP   rg   rN   rN   rO   r   8  s    zCallNode.type_dependenciesc             C   s   dS )NFrN   )rP   rN   rN   rO   r  =  s    zCallNode.is_simplec             C   s^   | j d k	r| j S | jj}|tkrT| jjrT| jj}|jjr<dS |jjrT|jt	j
krTdS tj| S )NF)may_return_noneru  r   r   r   r   r	  r
  rf   r   r  r   r  )rP   r  r   rN   rN   rO   r  D  s    
zCallNode.may_be_nonec             C   s   |d kr|j }|tjkrv|jrv|jrv|jjrv|jjtjkrv|jjdkrXtj	| _ tj	| _
ntj|jj | _ t| _
d| _n*|jr|jr|jj | _ t| _
d| _nt| _ d S )Nrq   F)r   r   r   r   r   r  rf   r  r   r  r   Zbuiltin_typesr   r  r5  )rP   ru  r  rN   rN   rO   set_py_result_typeQ  s$    


zCallNode.set_py_result_typec       	         s,  | j j }|r|jr| j \}}g }x<t||jjD ]*\}}|jt|j	t
|j	|jd|d q6W |rr||j7 }|| _t| _| j  | j|  dS |o|jr( fdd| jD | _|jjd}|st| j j	d| j j  t| _| S t| j j	|j| _ || j _| j j|j  | j  || _dS d S )N)rr   r   )rr   keyr   Tc                s   g | ]}|j  qS rN   )r   )rW   re  )rg   rN   rO   r   z  s    z8CallNode.analyse_as_type_constructor.<locals>.<listcomp>z<init>z'no constructor found for C++  type '%s')ru  r   r  explicit_args_kwdsr  r{  r{  r   DictItemNoderr   r  rf   key_value_pairsDictNoderM   r   rQ  r   r   r|  r   r,   r   r  r   r  r  analyse_c_function_call)	rP   rg   r   r   r  r~  re  memberr  rN   )rg   rO   analyse_as_type_constructork  s4    
&


z$CallNode.analyse_as_type_constructorc             C   s   | j jS )N)r   r   )rP   rN   rN   rO   r     s    zCallNode.is_lvaluec             C   s:   | j  }|jr| j  n|j r6t|dd r6| j  d S )Nr   F)function_typere   r  rU  r   )rP   rg   r  rN   rN   rO   r    s
    
zCallNode.nogil_checkzCalling gil-requiring function)N)rR   rS   rT   r  rv   r   r  r  r  r  r   r  r   rN   rN   rN   rO   r    s   (
r  c                   s   e Zd Zd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dd Zdd Zdd Zdd Zdd Z fddZdd Z  ZS ) r}  rP   coerced_selfru  r   r  NFc                sZ   | j j } fdd| jD }y|| S  tk
rT } z| j| W Y d d }~X nX d S )Nc                s   g | ]}|j  qS rN   )r   )rW   re  )r   rN   rO   r     s    z5SimpleCallNode.compile_time_value.<locals>.<listcomp>)ru  r   r   r  r   )rP   r   ru  r   r   rN   )r   rO   r     s    z!SimpleCallNode.compile_time_valuec             C   sP   |j }|j|j}|s(td||jf t||j||jd}| |||gd}|S )Nz Getter not found in scope %s: %s)rf   r   r   )ru  r   )r{  r  rf   r   r}  rP  r   )rL   rr   rs  r   Zproperty_scopeZgetter_entryru  rt   rN   rN   rO   for_cproperty  s    zSimpleCallNode.for_cpropertyc             C   s   | j j }|dkrdt| jdkr0t| jjd q| jd j|}|sXt| jd jd qtj|S n:|dkrt| jdkrt| jjd | jd j	|}|j
S d S )Npointerr%   zonly one type allowed.r   zUnknown typeZtypeof)ru  r  r{   r   r   rr   r   r   r  r   r   )rP   rg   rA  r   operandrN   rN   rO   r     s    
zSimpleCallNode.analyse_as_typec             C   s
   | j d fS )N)r   )rP   rN   rN   rO   r    s    z!SimpleCallNode.explicit_args_kwdsc                s  | j r
| S d| _ | j r| S d| j_| jj | _| j}|jrb|jrb|jjrb|j| _	t
| j	|_| j }d| _t r|jrt|rd}t| j| jd| _| jj | _x| jjD ]}|t|M }qW t|| _| jr jt| tj| t|| jtt|| jjdS |jrVt| j| jd| _| jj j | _d | _| j|| d| _ n2 fdd| jD | _| j!  |j"dkrd| _ | S )	NTr%   F)r   )function_cnamer  r   c                s   g | ]}|j  qS rN   )r   )rW   re  )rg   rN   rO   r     s    z0SimpleCallNode.analyse_types.<locals>.<listcomp>r   )#analysedr  ru  r\  r   r  r   
is_cmethodrs  rP   r  r  Zis_numpy_call_with_exprsr=   r  rB   rn  rr   r   r  r@   r   Zadd_include_filerC   NumPyMethodCallNoder  rD   rE   r:   re   rr  r  r   r  r   )rP   rg   ru  r  Zhas_pythran_argsre  rN   )rg   rO   r     sN    


zSimpleCallNode.analyse_typesc             C   s   | j j}|jr|j}|S )N)ru  r   rJ  rK  )rP   r  rN   rN   rO   r    s    zSimpleCallNode.function_typec             C   s  | j j}|tkrt| _d S |jrJ|jrJ| jrB| jjjrBt| jd | j	}n| jr`| jg| j	 }n| j	}|j
r| j jjjd}|d krtj| _d| _d S n6t| j dr| j j}n | j jr| j jr| j jj}nd }|rb| j jjr| j jj }dd |D }n|j }tjdd |D || j||}|s8tj| _d| _d S d|_|j
sN|| j _|j| j _| j }n6d }| j }|jst| jd	|  tj| _d| _d S t|j	}||j }	t|}
|jr|	|
krd
| _d
| _|r|jr|j	r|j r|j	d }|d }|jr`| jrH| jjdj t|j!dkr2dndd|j!gd| _n|jd|j!|jj!gd}| jr|j"r|t#| j}n
t$| j}|j%|j| }| _&n4|jj'r|j%|j|}|jj'rt(|t)rd|_*||d< d}xt+t,||
D ]}|j	| }|j}|| j%||}|jr"|jd}|jr:|dkrd}nP|jj-r|j. r|dkrf| jd k	rfn$|j/ rrn|dkrd}|j0|}|||< qW xt+||
D ]}|| }|jj-r|jt1krtj2}n
|jj3 }|d krt| j	|d
  jd n|j%|| ||< }|jr|dkrd}qW |rxt+|
d
 D ]}|dkr\| jd k	r\q>|| }|j/ rpnP|jj
r|nD|j.r|jj-rn0|dks|d
kr>| jd k	r>t4|jdd P q>W || j	d d < t(| j t5rtj6| j j7| _n|j8| _| j j9s| j j:r4| j j}|r4|j;s.|j<r4d
| _| jj-rLt=| _>d
| _n,|j?d k	s`|j@rhd
| _n| jjArxd
| _| jr| jjBrtjC| jjD| _|j@dkrtE|r|jFtGjHdd |jId | _Jd S )Nz4Cannot call a static method on an instance variable.z
operator()z<error>r   c             S   s   g | ]
}|j qS rN   )r   )rW   frN   rN   rO   r   .  s    z:SimpleCallNode.analyse_c_function_call.<locals>.<listcomp>c             S   s   g | ]
}|j qS rN   )r   )rW   re  rN   rN   rO   r   2  s    TzCalling non-function type '%s'r%   r   z*'NoneType' object has no attribute '%{0}s'   z.30rD  PyExc_AttributeError)r   r  z@descriptor '%s' requires a '%s' object but received a 'NoneType')r  FzGcannot pass None into a C function argument that is declared 'not None'z5Python object cannot be passed as a varargs parameterzTArgument evaluation order in C function call is undefined and may not be as expectedr   r  zCppSupport.cppoverflowcheck)Kru  r   r,   r   is_static_methodrP   r	  r   rr   r   r   r{  r|  r   r  rm  r   r  r  r   rL  r  r  rN  r  r{   optional_arg_counthas_optional_argsr   r  Znot_noner  r   rf   Zaccept_builtin_subtypesCMethodSelfCloneNoder  rQ  r  r
  ro   r`  exact_builtin_typerangeminre   r   r   r  r   ra   Zdefault_coerced_ctyper   r  r  r  r  r   r  rC  Zutility_code_definitionr   r   r   r   r   r   CFakeReferenceTyperI  r   r   r   r   r_   r  )rP   rg   r  r   Zoverloaded_entryZ	functypesr  r   	max_nargsexpected_nargsactual_nargs
formal_argre  some_args_in_tempsr  formal_typeZ	arg_ctyper  rN   rN   rO   r    s   





 













 


z&SimpleCallNode.analyse_c_function_callc             C   s   | j  S )N)c_call_code)rP   rN   rN   rO   r     s    z$SimpleCallNode.calculate_result_codec             C   s  | j  }| jtjks|j r dS |j}g }tt|| j}t|j}||j	 }t| j}x.|d | D ]\}}	|	j
|j}
|j|
 qfW |jr|jtt| jp| jjj |j	r||krd}n
d| j }|j| x(| jt|d  D ]}	|j|	j  qW d| jj dj|f }|S )Nz<error>r  z&%sz%s(%s)z, )r  r   r   r,   r   r   r   r  r{   r  r   r   r0  rk   r  wrapper_callru  r   is_unbound_cmethodopt_arg_structr   r   r  )rP   r  Zformal_argsZarg_list_coder   r  r  r  r  
actual_argarg_codeZoptional_argsr   rN   rN   rO   r    s.    




zSimpleCallNode.c_call_codec             C   s"   | j  }|j s|jdkrdS dS )Nr   FT)r  r   r   )rP   r  rN   rN   rO   r     s    z#SimpleCallNode.is_c_result_requiredc                s  | j }|js|jr |jj|j d}| jjo2| jj}| j	r|r|j
 |kr|jjtjdd |jd| jd j
 | jd jj |j| jf  |jj st| jjdks| jjr| jjrtt| j| d S | jjr| jjd nd }| j| j||f}x"|D ]}|d k	 r|j|  qW |j| j | js2t| j| |d kr|jjtjd	d
 |jd| j
 |j  |j!| j
 | jf  nD|jjtjdd
 |jd| j
 |j  |j  |j!| j
 | jf  | j"| x,|D ]$}|d k	r|j#| |j$| qW d S )Nabslabs__Pyx_abs_longlongZCommonz
Overflow.czif (unlikely(%s == __PYX_MIN(%s))) {                PyErr_SetString(PyExc_OverflowError,                                "Trying to take the absolute value of the most negative integer is not defined."); %s; }r   r%   ZPyObjectCallNoArgzObjectHandling.cz%%s = __Pyx_PyObject_CallNoArg(%s); %sPyObjectCallOneArgz*%s = __Pyx_PyObject_CallOneArg(%s, %s); %s)r  r  r  )%ru  r   r  r   use_entry_utility_coder   r   r\  r   r  r   r   r   r   r   r   r  r   rr   re   r{   r  r   rJ   r}  r(  rP   r  r"  r   r   r  r   r   r=  r+  r1  )rP   r   ru  Zabs_function_cnamesZis_signed_intre  r   Zsubexpr)rM   rN   rO   r(    sZ    











z'SimpleCallNode.generate_evaluation_codec             C   s<  | j  }|jrh| jj }|jjtjdd |jd| j	 | j
j ||j| j	 | jf  | j| n|jr8|jj }| jr*t| j}t|j|j }|jj|jjdd| _|jd| jtjd t| j| f  tt|j| j}x>||| D ].\}}	|jd| j|j|j|	j|j f  qW g }
| j jrT| j!rT|
j"d| j	   n| j j#r| j!sjt$|
j"| j j%| j	  n|j&d	kr@|j'}|j&}|d k	r|
j"d
| j	 |j(j)|f  |r@|r6|
st*| j
dd }t+j,| j|jj-|r|jnd | j j.d|o|j/d |jjtjdd |
j"d n
|
j"d | j!sN|
r"| j0 }| j	 rd| j	  }| j!r| j jrt1t2| j |}nd}|j&d	krt3|| jd||f | j jr| j	 nd |j'| n4|
r|j4dj5|
| j}nd}|jd|||f  | j jr"| j	 r"| j| | jr8|jj6| j d S )Nr  zObjectHandling.cz*%s = __Pyx_PyObject_Call(%s, %s, NULL); %sT)r  z%s.%s = %s;rW  z!%sr   z%s == %sr   )function_nameZvoid_returnZis_callZis_from_pxdr   zExceptions.cz__Pyx_ErrOccurredWithGIL()zPyErr_Occurred()z%s = rD  z%s%s;z && z%s%s; %s)7r  re   r  r   r   r   r   r   r   r   ru  r   rr   r=  r   r  	gil_ownedr  r{   r   r  r  op_arg_structrK  r  r   Zpyrex_prefixr   r  Zopt_arg_cnamerf   r   r   r   r   r   r   Zerror_conditionr   r   r  	cast_coder   r   Zwrite_noexcept_performance_hintr{  r  Zdefined_in_pxdr  r+   r   r   r   r  r  )rP   r   r  r  r   r  r  r   r  r  Z
exc_checksexc_valZ	exc_checkZperf_hint_entryr|   rB  Z
goto_errorrN   rN   rO   r#  7  s    











z#SimpleCallNode.generate_result_code)rR   rS   rT   r   rP   r  r  r  r  r   r  r  r   r  r  r   r  r   r  r  r   r  r   r(  r#  rU   rN   rN   )rM   rO   r}    s,   
0 L9r}  c               @   s"   e Zd ZdgZdZdZdd ZdS )r  r  Tc             C   s   |j | j | j| | jjd ks&t| jj}x|D ]}|j| q4W |jd |jd| j	   |jd| j	 | j	 | j
djdd |D f  d S )Nz.// function evaluation code for numpy functionz__Pyx_call_destructor(%s);z!new (&%s) decltype(%s){%s{}(%s)};z, c             s   s   | ]}|j  V  qd S )N)r   )rW   r  rN   rN   rO   rZ     s    z?NumPyMethodCallNode.generate_evaluation_code.<locals>.<genexpr>)r"  rr   r  r  r   r   r   r(  r   r   r  r  )rP   r   r   re  rN   rN   rO   r(    s    


z,NumPyMethodCallNode.generate_evaluation_codeN)rR   rS   rT   r   r   r  r(  rN   rN   rN   rO   r    s   r  c               @   s    e Zd ZddgZdZdd ZdS )PyMethodCallNoderu  r  Tc             C   sR  |j | j | j| | jj| | jjd ks2t| jj}x|D ]}|j| q@W | jj	}|rj| jj
 }nL|jjtdd}| jj| |jd|| jj f  | jj| | jj| |jjtdd}|jd|  |jjtjdd}|jd|  dd }| jjr|| jrd	nd
}	nl| jjr| jjrxV| jjD ]@}
|
j}|r:|jr:|jjr:|jjjr:||r:d	}	P q:W d
}	nd
}	|jd |jd|	|f  |jd||f  |jd|  |jd|  |j|t |jdt |j|td |jd|  |jd |jd |jd |jj t!j"dd |jd |jd|rZt#|d nd||rxdj$dd |D ndf  |jd| j
 ||t#||f  |j%|t |jj&| |jj&| x"|D ]}|j| |j| qW |j|j'| j
 | j | j(| |r,| jj| | jj| n|j)|t |jj&| |jd d S )NT)r  z	%s = %s; z
%s = NULL;Fz%s = 0;c             S   s   | j }|jr|jjrdS dS )NFT)rs  r   r   r2  )rA  rs  rN   rN   rO   attribute_is_likely_method  s    zMPyMethodCallNode.generate_evaluation_code.<locals>.attribute_is_likely_methodZlikelyZunlikelyz#if CYTHON_UNPACK_METHODSzif (%s(PyMethod_Check(%s))) {z%s = PyMethod_GET_SELF(%s);zif (likely(%s)) {z/PyObject* function = PyMethod_GET_FUNCTION(%s);ru  z%s = 1;r   z#endifZPyObjectFastCallzObjectHandling.cr  z(PyObject *__pyx_callargs[%d] = {%s, %s};r%   r2   z, c             s   s   | ]}|j  V  qd S )N)r   )rW   re  rN   rN   rO   rZ     s    z<PyMethodCallNode.generate_evaluation_code.<locals>.<genexpr>r  z=%s = __Pyx_PyObject_FastCall(%s, __pyx_callargs+1-%s, %d+%s);)*r"  rr   r  ru  r(  r  r   r   r   r   r   r  r  r   r  r  r   r+  r1  r   r   Zc_uint_typer  r   rz   r|   rs  r   re   r  r4  r   r   r   r   r{   r  r[  r  r   r=  r*  )rP   r   r   re  Zreuse_function_tempru  Zself_argZarg_offset_cnamer  Zlikely_methodr;  r   rN   rN   rO   r(    s    


$





$



z)PyMethodCallNode.generate_evaluation_codeN)rR   rS   rT   r   r   r(  rN   rN   rN   rO   r    s   r  c               @   s<   e Zd ZddgZdZeZdZdZdd Z	dd Z
d	d
 ZdS )InlinedDefNodeCallNoder   r  r%   Nc             C   s>   | j j}|js|jrdS t|jt| jkr0dS |jr:dS dS )NFT)ru  def_nodestar_argstarstar_argr{   r   num_kwonly_args)rP   r  rN   rN   rO   can_be_inlined"  s    z%InlinedDefNodeCallNode.can_be_inlinedc                s  | j j | _  fdd| jD | _| jj}t| j}d}x|t|D ]p}|j| j}| j| j| }|j	rz|dkrd}n0|jj
r j r|j rn|dkrd}|j }|| j|< qDW |rxZt|d D ]J}| j| }|j rq|jjrq̈ jr|jj
rq|dkrt|jdd P qW | S )Nc                s   g | ]}|j  qS rN   )r   )rW   re  )rg   rN   rO   r   /  s    z8InlinedDefNodeCallNode.analyse_types.<locals>.<listcomp>Fr   Tr%   zTArgument evaluation order in C function call is undefined and may not be as expected)r  r   r   ru  r  r{   r  r   rQ  r   re   r   r   r  r   r   rr   )rP   rg   r  r  r  r  r  re  rN   )rg   rO   r   ,  s>    


z$InlinedDefNodeCallNode.analyse_typesc             C   s   | j j g}| jj}xDt| j|jD ]2\}}|jjrH|j|j	|j q$|j|j
  q$W dj|}|jd| j
 | jjjj||j| j
 | jf  | j| d S )Nz, z%s = %s(%s); %s)r  r   ru  r  r  r   r   re   r   r   r   r  r   r   pyfunc_cnamer   rr   r=  )rP   r   r  r  re  Z	proto_argrN   rN   rO   r#  e  s    

z+InlinedDefNodeCallNode.generate_result_code)rR   rS   rT   r   r   r   r   ru  r  r  r   r#  rN   rN   rN   rO   r    s   
9r  c               @   s2   e Zd Zg Zd
ddZdd Zdd Zdd	 ZdS )PythonCapiFunctionNodeNc             C   s   t j| |||||d d S )N)rf   r   r   rC  )r   r  )rP   rr   py_namer   r  rC  rN   rN   rO   r  z  s    zPythonCapiFunctionNode.__init__c             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   ~  s    z$PythonCapiFunctionNode.analyse_typesc             C   s   | j r|jj| j  d S )N)rC  r   r   )rP   r   rN   rN   rO   r#    s    z+PythonCapiFunctionNode.generate_result_codec             C   s   | j S )N)r   )rP   rN   rN   rO   r     s    z,PythonCapiFunctionNode.calculate_result_code)N)rR   rS   rT   r   r  r   r#  r   rN   rN   rN   rO   r  w  s
   
r  c               @   s   e Zd ZdZdddZdS )PythonCapiCallNodeFNc             K   s8   |j | _| j| _t|||||d| _tj| |f| d S )N)rC  )r  r   r   r  ru  r}  r  )rP   rr   r  r  rC  r  r  rN   rN   rO   r    s    
zPythonCapiCallNode.__init__)NN)rR   rS   rT   r  r  rN   rN   rN   rO   r    s   r  c                   s8   e Zd ZddgZdZ fddZdd Zdd	 Z  ZS )
CachedBuiltinMethodCallNoders  r   Tc                s&   t t| j|j||||j|jd d S )N)rs  r   r   r  r   )rJ   r  r  rr   r  r   )rP   Z	call_noders  r   r   )rM   rN   rO   r    s
    
z$CachedBuiltinMethodCallNode.__init__c             C   s   | j d k	r| j S tj| S )N)r  r   r  )rP   rN   rN   rO   r    s    
z'CachedBuiltinMethodCallNode.may_be_nonec             C   sl   | j jj}| j j }dd | jD }|jj||| j|}|jd| j	 ||j
| j	 | jf  | j| d S )Nc             S   s   g | ]}|j  qS rN   )r   )rW   re  rN   rN   rO   r     s    zDCachedBuiltinMethodCallNode.generate_result_code.<locals>.<listcomp>z%s = %s; %s)rs  r   r   r   r   r   Zcached_unbound_method_call_coder   r   r   r   rr   r=  )rP   r   Z
type_cnameZ	obj_cnamer   Z	call_coderN   rN   rO   r#    s    

z0CachedBuiltinMethodCallNode.generate_result_code)	rR   rS   rT   r   r   r  r  r#  rU   rN   rN   )rM   rO   r    s
   r  c               @   sH   e Zd ZeZdddgZejZdd Z	dd Z
dd	 Zd
d Zdd ZdS )GeneralCallNoderu  r  r  c             C   s`   | j j|}| jj|}| jj|}y
|||S  tk
rZ } z| j| W Y d d }~X nX d S )N)ru  r   r  r  r  r   )rP   r   ru  r  r  r   rN   rN   rO   r     s    
z"GeneralCallNode.compile_time_valuec             C   s4   | j r| j j s| jj r&t| jd| jj| j fS )Nz0Compile-time keyword arguments must be explicit.)r  r  r  ry   r   rr   r   )rP   rN   rN   rO   r    s
    
z"GeneralCallNode.explicit_args_kwdsc             C   s   | j |r| S | jj|| _| jjjs| jjjr:t| _| S t| jdr| j }|d k	rh|| k	rh|j|S | jj	j
r| jj|| _q|| krt| jd qn| jj|| _| jr| jj|| _| jj|| _| jj|| _| j| j d| _| S )Nr   zRNon-trivial keyword arguments and starred arguments not allowed in cdef functions.r%   )r  ru  r   r   re   rU  r,   rm  map_to_simple_call_noder   r  rr  r   rr   r  r  r  r   )rP   rg   rt   rN   rN   rO   r     s2    




zGeneralCallNode.analyse_typesc                s  t | jts| S | jjs| S | j}t|dd}|s6| S |j}|jrH|j	}|j
sR| S | jj | j}|j}|jrx|dd }t t|krt| jdt|t f  dS dd |dt  D }|t d }d}t }	t|}
d}x>|jD ]4}|jj}||
krt|jd	|  d
}|
j| qW xPt||jD ]@\}}|jj}|j|krt|j| |d7 }|	j|j nP q8W ddlm}m} g }t|j|kr|t|	d }t fddt|jD }d}x|D ]}|j}||kr|s|}qn&|r |jr| S t| jd|  dS || \}}|j| |d7 }|jj rX|	j|j n0||j}|j spt |	j| |j||f qW |rg }g }|d d }xL|	D ]D}||krP |j r|j| n||}|j| |j| qW |r |}	|dd t!|D  }x6|jD ],}|jj}||krd
}t|jd|  qW |rXdS t"| j||	d}x"|ddd D ]}|||}qxW |S )z
        Tries to map keyword arguments to declared positional arguments.
        Returns self to try a Python call, None to report an error
        or a SimpleCallNode if the mapping succeeds.
        r   Nr%   zDfunction call got too many positional arguments, expected %d, got %sc             S   s   h | ]}|j r|j qS rN   )rf   )rW   re  rN   rN   rO   rx     s   z:GeneralCallNode.map_to_simple_call_node.<locals>.<setcomp>r   Fzargument '%s' passed twiceT)rU  
LetRefNodec                s(   g | ] \}}|j j|t  |ffqS rN   )r  r   r{   )rW   r  re  )pos_argsrN   rO   r   A  s   z;GeneralCallNode.map_to_simple_call_node.<locals>.<listcomp>z(C function call is missing argument '%s'c             S   s   g | ]\}}|qS rN   rN   )rW   r  re  rN   rN   rO   r   q  s    z/C function got unexpected keyword argument '%s')ru  r   rl  rl  )#ro   r  rn  r  r  ru  r   r   rJ  rK  r   r   r  r{   r   rr   r   setr  r  r   addr  rf   r   r]  rU  r  r	  r  r  r  r   r|  r}  )rP   ru  r   r  r  Zdeclared_argsZmatched_argsZunmatched_argsZmatched_kwargs_countr   seenZ
has_errorsre  rf   Zdecl_argrU  r  ZtempskeywordsZfirst_missing_keywordrr   r8  Z
final_argsZ	new_tempsZfirst_temp_arg	arg_valuert   rN   )r  rO   r    s    











z'GeneralCallNode.map_to_simple_call_nodec          	   C   sz   | j jrd S | jr| jj }nd}|jjtjdd |jd| j	 | j
j | jj ||j| j	 | jf  | j| d S )Nr  r  zObjectHandling.cz(%s = __Pyx_PyObject_Call(%s, %s, %s); %s)r   rU  r  r   r   r   r   r   r   r   ru  r  r   rr   r=  )rP   r   r  rN   rN   rO   r#    s     

z$GeneralCallNode.generate_result_codeN)rR   rS   rT   r   r   r   r(   r  r  r   r  r   r  r#  rN   rN   rN   rO   r    s   
	  r  c               @   sH   e Zd ZdgZdZdd Zdd Zdd Zd	d
 Ze	j
ZdZdd ZdS )AsTupleNodere  r%   c             C   s   t | jj| _d S )N)r   re  rp   )rP   rN   rN   rO   r     s    z%AsTupleNode.calculate_constant_resultc             C   sF   | j j|}yt|S  tk
r@ } z| j| W Y d d }~X nX d S )N)re  r   r   r  r   )rP   r   re  r   rN   rN   rO   r     s
    zAsTupleNode.compile_time_valuec             C   s6   | j j|j|| _ | j jtkr,| j jdS t| _| S )Nz!'NoneType' object is not iterable)re  r   rr  r   r   r  )rP   rg   rN   rN   rO   r     s
    zAsTupleNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r    s    zAsTupleNode.may_be_nonezConstructing Python tuplec             C   sT   | j jttfkrdnd}|jd| j || j j |j| j | jf  | j	| d S )NZ__Pyx_PySequence_TupleZPySequence_Tuplez%s = %s(%s); %s)
re  r   r   r   r   r   r   r   rr   r=  )rP   r   rw  rN   rN   rO   r#    s    
z AsTupleNode.generate_result_codeN)rR   rS   rT   r   r   r   r   r   r  r(   r  r  r   r#  rN   rN   rN   rO   r    s   r  c               @   sb   e Zd ZdgZdZeZdZdd Zdd Z	dd	 Z
d
d Zdd Zdd ZdZdd Zdd ZdS )MergedDictNoder  r%   Tc             C   sx   i }| j }xb| jD ]X}|jr.dd |jD }n
|jj }x0|D ](\}}|r^||kr^td| |||< q>W qW || _d S )Nc             s   s   | ]\}}|j |j fV  qd S )N)rp   )rW   r  r   rN   rN   rO   rZ     s   z;MergedDictNode.calculate_constant_result.<locals>.<genexpr>z$duplicate keyword argument found: %s)reject_duplicatesr  r  r  rp   	iteritemsr   )rP   r   r  rw   r~  r  r   rN   rN   rO   r     s    
z(MergedDictNode.calculate_constant_resultc       	         s   i }| j }x| jD ]}|jr2 fdd|jD }n|j j }y6x0|D ](\}}|rh||krhtd| |||< qHW W q tk
r } z| j| W Y d d }~X qX qW |S )Nc                s$   g | ]\}}|j  |j  fqS rN   )r   )rW   r  r   )r   rN   rO   r     s   z5MergedDictNode.compile_time_value.<locals>.<listcomp>z$duplicate keyword argument found: %s)	r  r  r  r  r   r  r   r  r   )	rP   r   r   r  rw   r~  r  r   r   rN   )r   rO   r     s    
 z!MergedDictNode.compile_time_valuec             C   s   f S )NrN   )rP   rg   rN   rN   rO   r     s    z MergedDictNode.type_dependenciesc             C   s   t S )N)r   )rP   rg   rN   rN   rO   rv     s    zMergedDictNode.infer_typec                s    fdd| j D | _ | S )Nc                s"   g | ]}|j  j jd qS )z1argument after ** must be a mapping, not NoneType)r   rr  r  )rW   re  )rg   rN   rO   r     s   z0MergedDictNode.analyse_types.<locals>.<listcomp>)r  )rP   rg   rN   )rg   rO   r     s    
zMergedDictNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r    s    zMergedDictNode.may_be_nonezConstructing Python dictc             C   s  |j | j | j| t| j}t|}|j| |jtk	rN|j	d|j
   |jr|j| |j	d| j |j
 f  |j| n>|j	d| j |j
 |j| j |jf  | j| |j| |jtk	r4|j	d |jjtjdd |j	d| j |j
 |j| j | jf  | j| |j| |j	d |j| t }xn|D ]d}|jrx|jD ]}|j| | jr|j	d	| j |jj
 f  |jd
 |j	d|jj
 |j| jf  |j	d |j|jjd| j |jj
 |jj
 f  |j| |j| qbW n|j| | jrJ|jd |j|jd| j |j
 f  nR|jd |j	d| j |j
 f  |j	d|j
   |j	|j|j |j	d |j| |j| qLW x&t|D ]}|jjtj|d qW d S )Nz$if (likely(PyDict_CheckExact(%s))) {z%s = %s;z%s = PyDict_Copy(%s); %sz} else {r  zObjectHandling.cz?%s = __Pyx_PyObject_CallOneArg((PyObject*)&PyDict_Type, %s); %sr   z(if (unlikely(PyDict_Contains(%s, %s))) {RaiseDoubleKeywordsz2__Pyx_RaiseDoubleKeywordsError("function", %s); %szPyDict_SetItem(%s, %s, %s)ZMergeKeywordsz__Pyx_MergeKeywords(%s, %s)ZRaiseMappingExpectedz*if (unlikely(PyDict_Update(%s, %s) < 0)) {zVif (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(%s);zFunctionArguments.c) r"  rr   r  rI  r  rJ  r(  r   r   r   r   r  r  r   r,  r   r=  r+  r   r   r   r   r1  r  r  r  r  r  r   r  r   r|  )rP   r   r   rw   helpersre  helperrN   rN   rO   r(    s    























z'MergedDictNode.generate_evaluation_codec             C   s   x| j D ]}|j| qW d S )N)r  rC  )rP   r   rw   rN   rN   rO   rC  Y  s    zMergedDictNode.annotateN)rR   rS   rT   r   r   r   r   r  r   r   r   rv   r   r  r   r(  rC  rN   rN   rN   rO   r    s   
Qr  c               @   sD  e Zd ZdZdgZdZdZdZdZdZ	dZ
dd Zd	d
 Zdd Zdd Zdd Zdd Zdd Zdd ZdJd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dKd)d*ZdLd+d,Zd-d. Zd/d0 Zd1Z d2d3 Z!d4d5 Z"d6d7 Z#d8d9 Z$d:d; Z%d<d= Z&d>d? Z'd@dA Z(dMdBdCZ)dNdDdEZ*dFdG Z+dHdI Z,dS )Or~  r%   rs  Nr   TFc             C   sF   t | jtr&| jjr&| jdk r&| jS | jj }|rBd|| jf S d S )Nparallelz%s.%s)ro   rs  rP  r8  rt  r  )rP   cyrN   rN   rO   r  w  s    
z!AttributeNode.as_cython_attributec             C   s  |t kr| j}|r:|jr:|jr:d| _|j| _| j| | S |r|jr| jjtj	k	rddl
m}m} || j| jjd}| jj|_|| _tj| ||}tjdd}tjtj tjdtj d tjdtj d g}	t| jd|	||g|d	}
|||
}|j|S tj| ||S )
Nr%   )rU  rV  )r   ZPyMethodNew2ArgzObjectHandling.cr  rP   Z__Pyx_PyMethod_New2Arg)r  r  r   rC  )r   r   r   r  r   analyse_as_python_attributers  r   r   r   r]  rU  rV  r   r   rQ  r   r   r   r  r  r  rr   r   )rP   rh  rg   r   rU  rV  Zobj_nodeZunbound_noderC  r  Zbinding_callZcomplete_callrN   rN   rO   rQ    s8    



zAttributeNode.coerce_toc             C   s2   | j }|jdr|jdrd S t| jj|| _d S )N__)rt  
startswithendswithr   rs  rp   )rP   rA  rN   rN   rO   r     s    z'AttributeNode.calculate_constant_resultc             C   sv   | j }|jdr.|jdr.t| jd|  d S | jj|}y
t||S  tk
rp } z| j	| W Y d d }~X nX d S )Nr  z6Invalid attribute name '%s' in compile-time expression)
rt  r  r  r   rr   rs  r   r   r  r   )rP   r   rA  rs  r   rN   rN   rO   r     s    

z AttributeNode.compile_time_valuec             C   s   | j j|S )N)rs  r   )rP   rg   rN   rN   rO   r     s    zAttributeNode.type_dependenciesc             C   s   | j |dd}|d k	r>|jjr6|jjjr6tj|jjS |jjS | j|}|d k	rX|jjS | jj|}| j	||d |j
r| jjrtS | jr| jjrtS | jS )NF)target)obj_type)#analyse_as_cimported_attribute_noder   r   r   r   r  analyse_as_type_attributers  rv   analyse_attributer
  r   r  )rP   rg   rt   r  rN   rN   rO   rv     s    
zAttributeNode.infer_typec             C   s
   d| _ d S )NT)r  )rP   rg   rN   rN   rO   r     s    z(AttributeNode.analyse_target_declarationc             C   sF   | j |dd}|jjr(t| jd| j  |j sBt| jd| j  |S )Nr%   )r  z"Assignment to const attribute '%s'z%Assignment to non-lvalue of type '%s')r   r   r  r   rr   rt  r   )rP   rg   rt   rN   rN   rO   r     s    z"AttributeNode.analyse_target_typesc             C   s   | j stj| _ |jd | _| j||}|d kr>| r>| j|}|d kr^| j||}|d k	s^t|j	sj|j
rx|jrxd|j_|j	r|j| |S )Nr*  T)r   r   r,   r_   r,  r  r  "analyse_as_ordinary_attribute_noder   r  r   r   rN  wrap_obj_in_nonecheck)rP   rg   r  rt   rN   rN   rO   r     s    

zAttributeNode.analyse_typesc             C   sr   | j j|}|rn|j| j}|rN|j rN|js@|js@|js@|jrN| j	|||S | j
|rnt| jd| j  | S d S )Nz&cimported module has no attribute '%s')rs  r   r  rt  r#  r@  r   r  r  as_name_noder9  r   rr   )rP   rg   r  module_scoper   rN   rN   rO   r    s    
z1AttributeNode.analyse_as_cimported_attribute_nodec                s"  j jrd S j j rjs0js0jrjjj}|r|j	sVjr|j
jrjrljsfd S |}n(j| } fdd|jD |_j |ddS nxjsjrjjkrxZjjD ] }|jjkr̈j |ddS qW tjdjf  ntjdjf  d S )Nc                s   g | ]}j | qS rN   )_create_unbound_cmethod_entry)rW   Zoverloaded_alternative)rg   rP   r   rN   rO   r     s   z;AttributeNode.analyse_as_type_attribute.<locals>.<listcomp>F)r  z%s not a known value of %s)rs  r  r   r	  r
  r   r{  r  rt  r  r   r   r\  r  Zoverloaded_alternativesr  rw  r6  r  r   Zenum_valuesrf   r   rr   )rP   rg   r   
ubcm_entryrN   )rg   rP   r   rO   r    s.    z'AttributeNode.analyse_as_type_attributec             C   s   |j r|jjd kr|j }|jjs.|jr6|jjr6|j}q|jrZt| jd|j	|f  t
j}qtj|j}|jd d  |_t
jd|dd |jd< nd|j|jf }|j}tj|j	||}d|_|j |_ d|_|j|_|S )Nz%s not a static member of %srP   r   z%s->%sr%   )Z
func_cnamer   r  r  parent_scopeZis_cpp_class_scoper   r   rr   rf   r   r,   re  r   r  Zvtabptr_cnamer   r   r7  r   r  r{  )rP   r   r   rg   r   r   r  rN   rN   rO   r  *  s&    z+AttributeNode._create_unbound_cmethod_entryc             C   sV   | j j|}|r|j| jS | j jsR| j j|}|rRt|dd d k	rR|jj| jS d S )Nr{  )rs  r   lookup_typert  r  r   r   r{  )rP   rg   r  rK  rN   rN   rO   r   D  s    zAttributeNode.analyse_as_typec             C   s@   | j j|}|r<|j| j}|r<|jr<|jjs6|jjr<|jS d S )N)rs  r   r  rt  r  r   r	  r
  )rP   rg   r  r   rN   rN   rO   r  N  s    
z'AttributeNode.analyse_as_extension_typec             C   s0   | j j|}|r,|j| j}|r,|jr,|jS d S )N)rs  r   r  rt  r"  )rP   rg   r  r   rN   rN   rO   r   Y  s    
zAttributeNode.analyse_as_modulec             C   s8   t j| | j|d}|r"|j|}n
|j|}d|j_|S )N)rf   r   r%   )rP  r  rt  r   r  r   rN  )rP   rg   r   r  rt   rN   rN   rO   r  c  s    
zAttributeNode.as_name_nodec             C   s   | j j|| _ | j| | jr.| jjr.| j r.| jrF|sd| _t| _	nT|rb| j j
jrbt| jd n8| jr| jjr|stj| j| j | jj|S t| jd | S )Nr%   z'Assignment to an immutable object fieldz"Assignment to a read-only property)rs  r   r  r   r  r\  
is_py_attrr   r   r   r   r
  r   rr   is_cpropertyr}  r  )rP   rg   r  rN   rN   rO   r  n  s    
z0AttributeNode.analyse_as_ordinary_attribute_nodec             C   s  |d k	}d| _ | j| _|d krJ| jjjs2| jjjr@| jj|| _| jj}n|jsV|jrZt}|j	sf|j
rt|j}d| _n.|js|jrd| _n|jr|jrd| _nd| _|jr|j r8|jj| j}|jo| r$| jdkrd| _d| _d| _| jjj| j| _d S |j| j|| j |jj| j}|rT|jrTd }nt| jd|  tj| _d S || _ |r|jr|j!dkrt| jd |j"r|j| _d S |j#r|j$ s|j%r|j| _|j&| _d S | j'||| d S )	Nr   z->rj  TTz/Cannot select attribute of incomplete type '%s'__weakref__z,Illegal use of special attribute __weakref__)(r  rt  r  rs  r   r$  r%  rr  r   rJ  r   rK  r5  r	  r
  r   Zis_fake_referenceZhas_attributesZattributes_knownr{  r  r   is_memslice_transposer   r  Z	transposerr   Zdeclare_attributerQ  r   r   r,   r   rf   r  r)  r1  r  r   r  )rP   rg   r  immutable_objr   rN   rN   rO   r    s`    


zAttributeNode.analyse_attributec             C   s   |d kr| j j}|j| j| _| j| _t| _d| _|j r|j r|j	s|j
s|js|js|js|jrp|j|s|jr|j|r|s| j j|| _ nX|jr| j js| j jr| j jjr| j jjjjr|s| j j|| _ nt| jd|| jf  d S )Nr%   z)Object of type '%s' has no attribute '%s')rs  r   Zmangle_class_private_namert  r  r   r  re   rU  r$  rd  r-  r   r  r  r  	is_structrr  r   r   r  r   r  r   rr   )rP   rg   r  r  rN   rN   rO   r    s,    
z)AttributeNode.analyse_as_python_attributec             C   s   |j d sd S d }f }| jjjrT| jrT| j rTdjt| jdkrDdnd}| jf}n8| jjj	r| j
rjd}n"| jjjj| j}|rd}|jf}|r| jj|d|d	| _d S )
Nr  z*'NoneType' object has no attribute '%{0}s'r  z.30rD  z&Cannot transpose None memoryview slicez5Cannot access '%s' attribute of None memoryview slicer  )r  )r_   rs  r   r	  needs_none_checkr  r   r{   rt  r   r  r{  r  rf   r  )rP   rg   rk  r  r   rN   rN   rO   r    s$    



z#AttributeNode.wrap_obj_in_nonecheckc             C   s   | j r| j  d S )N)r  r  )rP   rg   rN   rN   rO   r    s    zAttributeNode.nogil_checkzAccessing Python attributec             C   s   | j j|S )N)rs  r9  )rP   rg   rN   rN   rO   r9    s    z0AttributeNode.is_cimported_module_without_shadowc             C   s&   | j r| j p| j j S tj| S d S )N)rs  r
  r  rP  )rP   rN   rN   rO   r  
  s    zAttributeNode.is_simplec             C   s   | j r
dS tj| S d S )NT)rs  rP  r   )rP   rN   rN   rO   r     s    zAttributeNode.is_lvaluec             C   s   | j r| j j S tj| S d S )N)rs  r   rP  )rP   rN   rN   rO   r     s    
zAttributeNode.is_ephemeralc             C   s*   | j  }| jr&| jjr&| j r&d| }|S )Nz(*%s))calculate_access_coder   rA  r  )rP   r   rN   rN   rO   r     s    z#AttributeNode.calculate_result_codec             C   s   | j }|j|j}| jr| jjr|jjrr| jj rr| jjrB| jjS | jjrT| jj	| _
d|jj|| j|jj| j
f S | jr~| j
S d S |jjrd| j
j |f S |jjr| jr| jjr|jj|j dd}d|| j| j
f S d S )Nz((struct %s *)%s%s%s)->%sz__Pyx_C%s(%s)T)Zto_object_structz%s%s%s)rs  r   r   r   r  r	  Zis_builtin_cmethodZfinal_func_cnameZ
from_fusedr   r  Zvtabstruct_cnamer5  Zvtabslot_cnamer  rb  upperr
  r)  r  r   )rP   rs  Zobj_coderN   rN   rO   r  "  s&    
z#AttributeNode.calculate_access_codec          	   C   s  | j r| jr&|jjtjdd d}n|jjtjdd d}|jd| j || jj	 |j
| j|j| j | jf  | j| nP| jjr@| jrx,| jjD ] \}}|dkrt| jd d S qW |jd	| j | jj f  |j| j | jd
d d| j  }|j|j|| j n&| jr|jd| j |j| jf  n| jjr| jr| jrd| j }n| j srt| j }| jj|}|j| j| j|d n8| jjr| jjj rn | jr| jj!r|jj"| j d S )NZPyObjectLookupSpecialzObjectHandling.cZ__Pyx_PyObject_LookupSpecialZPyObjectGetAttrStrZ__Pyx_PyObject_GetAttrStrz%s = %s(%s, %s); %sr6  z=Transposing not supported for slices with indirect dimensionsz%s = %s;T)r  z__pyx_memslice_transpose(&%s)zeif (unlikely(!%s.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");%s})rB  )#r  is_special_lookupr   r   r   r   r   r   rs  r   rE  rt  r   rr   r=  r   r   r  r  r   r  r  r,  r   r   rA  r  r   r   r  rI  rJ  r	  r  r  )rP   r   Zlookup_func_namer?  r@  r  Zundereferenced_resultrB  rN   rN   rO   r#  F  sT    


z"AttributeNode.generate_result_codec             C   s<   | j r,| jjr,| jr,|j| j | jdd ntj| | d S )NT)r  )r   r   r   r  r[  r   r   r+  )rP   r   rN   rN   rO   r+    s    z$AttributeNode.generate_disposal_codec             C   s  | j j| | jrh|jjtjdd |j| jd| j j	 |j
| j|j	 f  |j| |j| n| j jjr|jd| jj | j jj| j j| j j|j| j f  |j| |j| n| j }| jjo| jr|j| |j| |j|| j |j|| j  n.| jjr:ddlm} |j |||j | j| | jjs`|jd||j!| j f  |j"| |j| | j j| | j j| d S )NrY  zObjectHandling.cz%__Pyx_PyObject_SetAttrStr(%s, %s, %s)z__Pyx_SET_C%s%s(%s, %s);r%   )rE  z%s = %s;)#rs  r(  r  r   r   r   r   r  rr   r   rE  rt  r+  r1  r   rb  r   r  r  Zimplementation_suffixr   r   r   re   r  r  r@  r:  
put_decrefr   rD  rE  Zput_assign_to_memviewslicer   r,  )rP   r|   r   r-  r   r   Zselect_coderE  rN   rN   rO   r.    sL    









z&AttributeNode.generate_assignment_codec             C   s   | j j| | js*| jjjrdd| jjjkrd|jjt	j
dd |j| jd| j j |j| jf  nt| jd | j j| | j j| d S )N__del__rY  zObjectHandling.cz!__Pyx_PyObject_DelAttrStr(%s, %s)z+Cannot delete C attribute of extension type)rs  r(  r  r   r{  Zis_property_scoper}  r   r   r   r   r  rr   r   rE  rt  r   r+  r1  )rP   r   r/  rN   rN   rO   r0    s    z$AttributeNode.generate_deletion_codec             C   s@   | j rd\}}nd\}}|j| jt||| j t| jd d S )Npy_attrpython attribute (%s)c_attrc attribute (%s))ra  )r  r  )r  r  )r  rC  rr   r3   r   r{   rt  )rP   r   rb  rc  rN   rN   rO   rC    s    
zAttributeNode.annotatec             C   s&   | j j }|r"tjd|| jf S d S )Nz%s.%s)rs  r  r	   r  rt  )rP   rg  rN   rN   rO   r    s    
z/AttributeNode.get_known_standard_library_import)r   )N)NF)FNN)F)-rR   rS   rT   r  r   r   r\  r  r  r  r  r  rQ  r   r   r   rv   r   r   r   r  r  r  r   r  r   r  r  r  r  r  r  r   r9  r  r   r   r   r  r#  r+  r.  r0  rC  r  rN   rN   rN   rO   r~  ^  sV   *
#


F
$9 
+
r~  c               @   sb   e Zd ZdgZdZ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d Zdd ZdS )StarredUnpackingNoder  r%   Fc             C   s   t j| ||d d S )N)r  )r   r  )rP   rr   r  rN   rN   rO   r    s    zStarredUnpackingNode.__init__c             C   s"   | j st| jd | jj| d S )Nz&starred expression is not allowed here)starred_expr_allowed_herer   rr   r  rw  )rP   rg   rN   rN   rO   rw    s    z)StarredUnpackingNode.analyse_declarationsc             C   s   | j j|S )N)r  rv   )rP   rg   rN   rN   rO   rv     s    zStarredUnpackingNode.infer_typec             C   s.   | j st| jd | jj|| _| jj| _| S )Nz&starred expression is not allowed here)r   r   rr   r  r   r   )rP   rg   rN   rN   rO   r     s
    
z"StarredUnpackingNode.analyse_typesc             C   s   | j j| d S )N)r  r   )rP   rg   rN   rN   rO   r     s    z/StarredUnpackingNode.analyse_target_declarationc             C   s   | j j|| _ | j j| _| S )N)r  r   r   )rP   rg   rN   rN   rO   r     s    
z)StarredUnpackingNode.analyse_target_typesc             C   s   dS )NrD  rN   )rP   rN   rN   rO   r     s    z*StarredUnpackingNode.calculate_result_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r#    s    z)StarredUnpackingNode.generate_result_codeN)rR   rS   rT   r   r  r   r   r   r   r  rw  rv   r   r   r   r   r#  rN   rN   rN   rO   r    s   r  c                   s   e Zd ZddgZdZdZdZ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 Zdd Zd-ddZ fddZd.ddZejejejejd ejdgZd!d" Zd#d$ Zd/d&d'Zd(d) Zd*d+ Z  Z S )0SequenceNoder   r   r%   NFc                s    fdd| j D S )Nc                s   g | ]}|j  qS rN   )r   )rW   re  )r   rN   rO   r     s    z8SequenceNode.compile_time_value_list.<locals>.<listcomp>)r   )rP   r   rN   )r   rO   compile_time_value_list  s    z$SequenceNode.compile_time_value_listc             C   sX   d| _ g }xB| jD ]8}|jr@| j r.t|jd d| _ |j}d|_|j| qW || _d S )NFz,more than 1 starred expression in assignmentT)starred_assignmentr   r  r   rr   r  r   )rP   r   re  rN   rN   rO   replace_starred_target_node  s    z(SequenceNode.replace_starred_target_nodec             C   s&   | j   x| jD ]}|j| qW d S )N)r  r   r   )rP   rg   re  rN   rN   rO   r   )  s    z'SequenceNode.analyse_target_declarationc             C   sp   x4t | jD ]&\}}|s"|j|}|j|| j|< qW | jrf| jj|}|jjsZ|j|}|j|| _d| _| S )Nr%   )	r  r   r   rr  r   r   r\  r   r   )rP   rg   skip_childrenr  re  r   rN   rN   rO   r   .  s    

zSequenceNode.analyse_typesc                st   | j |kr| S | j stt| j|jkrFt| jd|jt| jf   fddt| j|j	D }t
| j||ddS )NzHtrying to coerce sequence to ctuple of wrong length, expected %d, got %dc                s   g | ]\}}|j | qS rN   )rQ  )rW   re  r   )rg   rN   rO   r   C  s    z1SequenceNode.coerce_to_ctuple.<locals>.<listcomp>T)r   r   r   )r   r   r   r{   r   ra  r   rr   r  r  rn  )rP   rh  rg   coerced_argsrN   )rg   rO   coerce_to_ctuple<  s    
zSequenceNode.coerce_to_ctuplec          	   C   s   | j   tdd | jD s | S g }g }xV| jD ]L}|jrr|rd|jt|d j|dj|dd g }|j|j q0|j| q0W |r|jt|d j|dj|dd t	| j|| j
}| jrt| jd|| jj|d| j
dd}|S )	Nc             s   s   | ]}|j V  qd S )N)r  )rW   re  rN   rN   rO   rZ   H  s    z?SequenceNode._create_merge_node_if_necessary.<locals>.<genexpr>r   )r   T)r  r   )inplacer   r   )_flatten_starred_argsr`   r   r  r   rn  rr   r   r  MergedSequenceNoder   r   
binop_noderr  )rP   rg   r   r  re  rt   rN   rN   rO   _create_merge_node_if_necessaryF  s(    ""z,SequenceNode._create_merge_node_if_necessaryc             C   sX   g }x@| j D ]6}|jr8|jjr8|jj r8|j|jj  q|j| qW || j d d < d S )N)r   r  r  ry   r   r   r   )rP   r   re  rN   rN   rO   r	  ^  s    z"SequenceNode._flatten_starred_argsc             C   s   dS )NFrN   )rP   rN   rN   rO   r  g  s    zSequenceNode.may_be_nonec             C   s   | j rt| jd g | _g | _d| _xt| jD ]\}}|j| }| j|< |j	rz|j
jtsjt|jd |j
tkrzt|_
t| j|}|j|j
|}||k	rd| _| jj| | jj| q0W t| _
| S )Nz#can't assign to multiplied sequenceFz2starred target must have Python object (list) typeT)r   r   rr   unpacked_itemscoerced_unpacked_itemsZany_coerced_itemsr  r   r   r  r   rc  r   r   r  rQ  r   )rP   rg   r  re  Zunpacked_itemZcoerced_unpacked_itemrN   rN   rO   r   j  s*    
z!SequenceNode.analyse_target_typesc             C   s   | j | d S )N)generate_operation_code)rP   r   rN   rN   rO   r#    s    z!SequenceNode.generate_result_codec          	   C   s
  |d kr| j  }d }}d }| jr| r| j}|jjr|j  }t|jtr`|jdkr`d|j }n |jjrvd||f }n
d|f }| jtkr| j	s| j
r| r|jd|t| jdjdd	 | jD |j|| jf  |j|t n| jjr"x.t| jD ] \}}|jd
|||j  f  qW np| jtkr8d\}	}
n$| jtkrNd\}	}
ntd| j t| j}|jd||	|||j|| jf  |j|t |rtj}|jd|  |dkr|}nd||f }|jd||||f  nd}xt|D ]}| j| }|s|j  r$|j|j  |j  |j| |jd|
||rR|rRd||f pZ|pZ||j |j| jf  qW |r|jd |jd |d k	r|jj r|jdtj||j |jtj| jf  |jtjt |j!|t |jd|tjf  |jd d S )NrD  r   z * %sz * ((%s<0) ? 0:%s)z * (%s)z%s = PyTuple_Pack(%d, %s); %sz, c             s   s   | ]}|j  V  qd S )N)r   )rW   re  rN   rN   rO   rZ     s    z>SequenceNode.generate_sequence_packing_code.<locals>.<genexpr>z%s.f%s = %s;
PyList_New__Pyx_PyList_SET_ITEMPyTuple_New__Pyx_PyTuple_SET_ITEMz'sequence packing for unexpected type %sz%s = %s(%s%s); %sz{ Py_ssize_t %s;r%   z%s * %szfor (%s=0; %s < %s; %s++) {zif (%s(%s, %s, %s)) %s;z%s + %sr   z5{ PyObject* %s = PyNumber_InPlaceMultiply(%s, %s); %sz%s = %s;)r  r  )r  r  )"r   r   r   r\  ro   rp   r#   r   r   r   slowr   r{   r   r  r   rr   r:  r   r  r  r   r   r   r  r  r
  r  r   r@  r   r   re   r  )rP   r   r  plainZsize_factorZc_multr   r  re  Zcreate_funcZset_item_func	arg_countcounteroffsetrN   rN   rO   generate_sequence_packing_code  s    








"

z+SequenceNode.generate_sequence_packing_codec                sz   | j r"| j jjr"tt| j| nT| jtkrJ| js8| jrJtt| j| n,x| j	D ]}|j
| qRW | j rv| j j| d S )N)r   r   r\  rJ   r  r&  r   r   r  r   r,  r+  )rP   r   re  )rM   rN   rO   r&    s    z+SequenceNode.generate_subexpr_disposal_codec             C   sH   | j r| j|| n| j|| x| jD ]}|j| q(W |j| d S )N)r   generate_starred_assignment_code!generate_parallel_assignment_coder  r  r1  )rP   r|   r   r-  r   r   rw   rN   rN   rO   r.    s    z%SequenceNode.generate_assignment_coder  c             C   s   x| j D ]}|j| qW |jtkp:|jttfkp:|jj }t| j dk}|r`| j|||d n(|j	d | j
||| j |d |j	d x| jD ]}|j| qW x.tt| jD ]}| j| j| j| | qW d S )NrG   )use_loopr  r   )r  r  r   r   r   r   r
  r{   (generate_special_parallel_unpacking_coder   (generate_generic_parallel_unpacking_coder  r(  r  r   r.  )rP   r|   r   rw   Zspecial_unpackZlong_enough_for_a_loop
value_noder  rN   rN   rO   r    s$    




z.SequenceNode.generate_parallel_assignment_codec             C   s  d}d|j   }|jtkr.dg}|j rx|}nJ|jtkrLdg}|j rx|}n,ddg}d|j   }d|j   }d||f }|jd|  |jd	|j    |jd
 |jdt| j  |jj	t
jdd |jdt| jt| jf  |jj	t
jdd |jd |j|j| j |jd |jd t|dkrL|jd|d   x4t| jD ]&\}	}
|jd|
j |d |	f  qXW t|dkr|jd x4t| jD ]&\}	}
|jd|
j |d |	f  qW |jd x$| jD ]}
|j|
j |
j  qW |jd |sdxt| jD ]B\}	}
|jd|
j |	|j|
j | jf  |j|
j |
j qW n|jd |jd |jdt| jdjdd  | jD f  |jd!t| j  |jd"|jd#| j  |jd#t |jd$ |jd |jd |jd% |j| |dkr"|jd nr||krl|jd |jj	t
jd&d |jd'|j| j  |jd n(|jd | j||| j|d( |jd d S ))N1zlikely(%s != Py_None)r  r  zlikely(PyTuple_CheckExact(%s))zPyList_CheckExact(%s)z(%s) || (%s)z	if (%s) {zPyObject* sequence = %s;z2Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);zif (unlikely(size != %d)) {ZRaiseTooManyValuesToUnpackzObjectHandling.cz1if (size > %d) __Pyx_RaiseTooManyValuesError(%d);RaiseNeedMoreValuesToUnpackz9else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);r   z<#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFSr2   z(if (likely(Py%s_CheckExact(sequence))) {r   z"%s = Py%s_GET_ITEM(sequence, %d); z} else {r%   z#elsez&%s = PySequence_ITEM(sequence, %d); %sr  zPy_ssize_t i;zPyObject** temps[%s] = {%s};r  c             S   s   g | ]}d |j   qS )z&%s)r   )rW   rw   rN   rN   rO   r   V   s    zISequenceNode.generate_special_parallel_unpacking_code.<locals>.<listcomp>zfor (i=0; i < %s; i++) {z1PyObject* item = PySequence_ITEM(sequence, i); %srw   z*(temps[i]) = item;z#endifZRaiseNoneIterErrorz%__Pyx_RaiseNoneNotIterableError(); %s)r  )r   r   r   r  r   r   r{   r   r   r   r   r   r   rr   r  r  r   r  r   r   r:  r  r   r+  r  )rP   r   r|   r  Zsequence_type_testZ
none_checkr1   Ztuple_checkZ
list_checkr  rw   rN   rN   rO   r     s    



















z5SequenceNode.generate_special_parallel_unpacking_codeTc             C   sN  |j jtjdd |j jtjdd |jd |r^|jdt| jdjdd |D f  |jj	t
d	d
}|jd||j |j|| jf  |j|t
 |j| |jj	| jdd
}|jd||f  |jd}d||f }	|r2|jdt|  |jd|	  |j| |jdt
 |jd |jd nJxHt|D ]<\}
}|jd|
|j |	|j f  |j| |j| q<W |r|j jtjdd |j| jd|	t|f  |jd|  |j|t
 |jd}|j| |j| |j|t
 |jd|  |jd |j|j| j |j| |jj| |rJ|jj| d }|S )Nr!  zObjectHandling.cZ
IterFinishzPy_ssize_t index = -1;zPyObject** temps[%s] = {%s};r  c             S   s   g | ]}d |j   qS )z&%s)r   )rW   rw   rN   rN   rO   r   {   s    zISequenceNode.generate_generic_parallel_unpacking_code.<locals>.<listcomp>T)r  z%s = PyObject_GetIter(%s); %sFz(%s = __Pyx_PyObject_GetIterNextFunc(%s);Zunpacking_failedz%s(%s)z$for (index=0; index < %s; index++) {z*PyObject* item = %s; if (unlikely(!item)) rw   z*(temps[index]) = item;r   z(index = %d; %s = %s; if (unlikely(!%s)) ZUnpackItemEndCheckz$__Pyx_IternextUnpackEndCheck(%s, %d)z
%s = NULL;Zunpacking_donezCif (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);)r   r   r   r   r   r{   r  r  r  r  r   r   r   rr   r:  r+  r  r  r  r  r  r   r=  r  r*  r  r   r  )rP   r   r|   r  r  	terminateiterator_tempZiternext_funcZunpacking_error_labelZunpack_coder  rw   Zunpacking_done_labelrN   rN   rO   r  q   sv    











z5SequenceNode.generate_generic_parallel_unpacking_codec          	   C   s~  xPt | jD ]:\}}|jr| j| }| jd | }| j|d d  }P qW dsRtd }|rx|D ]}	|	j| q`W |jd | j|||ddd}x(t |D ]\}}	| j| }
|
j	| qW |jd |j| |j
 }|jd|| r|jr|jttfkrdnd	|p
|j |j|| jf  |j| |rH|j|t |jj| n
|j| |rN|jjtjd
d |jjtjdd}|jd||f  |jd|t|f  |jdt|||j| jf  |jd x"|d d d D ]}	|	j| qW xt t |d d d | jd d d D ]\}\}	}|jd |jd|	j |||d f  |jd|  |jd |jd|	j |||d f  |jd |	j| |j	| qW |jd |jjtdd}|jd|||t||j|| jf  |j!|t |jj| |j"|t |jd|||f  |jd |jd|  |jj| |jd x*t | jD ]\}}|j#| j| | qZW d S )Nr%   Fr  T)r  r"  r   z%s = %s(%s); %s__Pyx_PySequence_ListKeepNewPySequence_Listr!  zObjectHandling.c)r  z%s = PyList_GET_SIZE(%s);zif (unlikely(%s < %d)) {z)__Pyx_RaiseNeedMoreValuesError(%d+%s); %sz#if CYTHON_COMPILING_IN_CPYTHONz!%s = PyList_GET_ITEM(%s, %s-%d); z((PyVarObject*)%s)->ob_size--;z#elsez!%s = PySequence_ITEM(%s, %s-%d); z#endifz #if !CYTHON_COMPILING_IN_CPYTHONz*%s = PySequence_GetSlice(%s, 0, %s-%d); %sz%s = %s; %s = NULL;zCYTHON_UNUSED_VAR(%s);rl  rl  rl  )$r  r   r  r  r   r  r   r  r  r(  r   r   r   r   r   r   r   rr   r=  r*  r  r  r+  r   r   r   r   r  r   r   r{   r   r  r:  r  r.  )rP   r|   r   r  re  Zstarred_targetZunpacked_fixed_items_leftZunpacked_fixed_items_rightr#  rw   r  Ztarget_listZlength_tempZcoerced_argZsublist_temprN   rN   rO   r     s    









 






z-SequenceNode.generate_starred_assignment_codec             C   sX   x| j D ]}|j| qW | jrTx| jD ]}|j| q(W x| jD ]}|j| qBW d S )N)r   rC  r  r  )rP   r   re  rN   rN   rO   rC  !  s    zSequenceNode.annotate)F)NF)FNN)T)!rR   rS   rT   r   ry   r  r   r  r  r  r   r   r  r  r	  r  r   r#  r  r&  r.  r   r  r  r   r  r  r  r  r  r  rC  rU   rN   rN   )rM   rO   r    s6   	

	
Y 

Z
GTr  c               @   sr   e Zd Ze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 Zdd Zdd Zdd ZdS )rn  FzConstructing Python tuplec                sL   | j s| j rtS  fdd| jD }tdd |D r<tS  j| j|jS )Nc                s   g | ]}|j  qS rN   )rv   )rW   re  )rg   rN   rO   r   !!  s    z(TupleNode.infer_type.<locals>.<listcomp>c             s   s&   | ]}|j p|jp|jp|jV  qd S )N)re   r   r  r   )rW   r   rN   rN   rO   rZ   "!  s   z'TupleNode.infer_type.<locals>.<genexpr>)r   r   r   r`   declare_tuple_typerr   r   )rP   rg   r  rN   )rg   rO   rv   !  s    
zTupleNode.infer_typec             C   s\  | j rd| _ | jrd| _t| jdkr6d| _d| _ | S |snx2t| jD ]$\}}|jrZd|_|j|| j|< qFW | j	 rt
dd | jD  r|j| jdd | jD j| _d| _| S tj| |dd}|j|}|js|S td	d |jD s|S |j	 s|j	j r"t|j	jtr"d|_d|_ n6|j	jj rL|j	jj rL|j	j||_	d|_d|_|S )
NFr   Tc             s   s,   | ]$}|j p"|jjp"|jjp"|jjV  qd S )N)r  r   re   r   r   )rW   re  rN   rN   rO   rZ   9!  s   z*TupleNode.analyse_types.<locals>.<genexpr>c             s   s   | ]}|j V  qd S )N)r   )rW   re  rN   rN   rO   rZ   ;!  s    r%   )r  c             s   s   | ]}|j V  qd S )N)r   )rW   childrN   rN   rO   rZ   D!  s    )r   is_partly_literalr{   r   r   r  r  r   r   r   r`   r&  rr   r   r  r  ry   r  ro   rp   r#   re   r\  rr  )rP   rg   r  r  re  rt   rN   rN   rO   r   '!  sF    


zTupleNode.analyse_typesc                sH   | j s
d S  fdd| j D }tdd |D r4d S  j| j|}|jS )Nc                s   g | ]}|j  qS rN   )r   )rW   re  )rg   rN   rO   r   V!  s    z-TupleNode.analyse_as_type.<locals>.<listcomp>c             s   s   | ]}|d kV  qd S )NrN   )rW   rX   rN   rN   rO   rZ   W!  s    z,TupleNode.analyse_as_type.<locals>.<genexpr>)r   r`   r&  rr   r   )rP   rg   r   r   rN   )rg   rO   r   R!  s    zTupleNode.analyse_as_typec                s   | j jr|jr(| j j|jkr(| j| S |tks8|tkrl fdd| jD }t| j|t| j	ddj
 ddS | j j| S n(|jr| j	 r| j| S tj| | S d S )Nc                s   g | ]}|j  qS rN   )rr  )rW   re  )rg   rN   rO   r   a!  s    z'TupleNode.coerce_to.<locals>.<listcomp>r%   )r   r   r   r   T)r  )r   r  ra  r  r   r   r   rn  rr   r   r   rr  rQ  r  )rP   rh  rg   r  rN   )rg   rO   rQ  \!  s     
zTupleNode.coerce_toc             C   s0   t | j| j| jd}t| jtr,t| j|_|S )N)r   r   )rN  rr   r   r   ro   rp   r   r   )rP   rX   rN   rN   rO   as_listp!  s    zTupleNode.as_listc             C   s   dS )NTrN   )rP   rN   rN   rO   r  v!  s    zTupleNode.is_simplec             C   s   dS )NTrN   )rP   rN   rN   rO   r   z!  s    zTupleNode.nonlocally_immutablec             C   s   t | jdkr| jS tjS d S )Nr   )r{   r   r  r   empty_tuple)rP   rN   rN   rO   r   ~!  s    zTupleNode.calculate_result_codec             C   s   t dd | jD | _d S )Nc             S   s   g | ]
}|j qS rN   )rp   )rW   re  rN   rN   rO   r   !  s    z7TupleNode.calculate_constant_result.<locals>.<listcomp>)r   r   rp   )rP   rN   rN   rO   r   !  s    z#TupleNode.calculate_constant_resultc             C   sD   | j |}yt|S  tk
r> } z| j| W Y d d }~X nX d S )N)r  r   r  r   )rP   r   r  r   rN   rN   rO   r   !  s
    
zTupleNode.compile_time_valuec             C   sH  t | jdkrd S | js | jr0t| j| jr2| jnd g| j }|jtdd|d}|j	|}|d k	r|j
| j | j||| j d |j|t | jr|| _n| jjjr|jjtjdd |jd| j || jj |j| j | jf  | j| n8|jd	| j || jj |j| j | jf  | j| nd
| jj_| j| d S )Nr   r   r2   )r~  r  )r  PySequenceMultiplyzObjectHandling.cz*%s = __Pyx_PySequence_Multiply(%s, %s); %sz"%s = PyNumber_Multiply(%s, %s); %sT)r{   r   r   r(  r   r   r   r  r   r  r"  rr   r  r?  r  r\  r   r   r   r   r   r   r   r=  r   r   rN  )rP   r   r  Ztuple_targetr  rN   rN   rO   r  !  s2     


z!TupleNode.generate_operation_codeN)F)rR   rS   rT   r   r   r(  r   rv   r   r   rQ  r)  r  r   r   r   r   r  rN   rN   rN   rO   rn  !  s   	
+
rn  c               @   st   e Zd Zg Z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d Zdd Zdd Zdd Zdd ZdS )rN  FzConstructing Python listc             C   s   f S )NrN   )rP   rg   rN   rN   rO   r   !  s    zListNode.type_dependenciesc             C   s   t S )N)r   )rP   rg   rN   rN   rO   rv   !  s    zListNode.infer_typec             C   s2   x| j D ]}|jrd|_qW tj| |}|j|S )NT)r   r  r   r  r   rr  )rP   rg   re  rt   rN   rN   rO   r   !  s
    
zListNode.analyse_expressionsc          
   C   sN   t dd}t| j| _tj| |}W d Q R X ||_|jr@d| _|j	|}|S )NT)r  )
r   r   r   original_argsr  r   obj_conversion_errorsr  rP  r  )rP   rg   errorsrt   rN   rN   rO   r   !  s    
zListNode.analyse_typesc       	      C   s0  |j rDx| jD ]}t| qW g | _| jj|s@t| jd|  n|jsP|joZ|j	t
jk	rt| j}| jrt| jjtr| jjdkrt| jd|  q|| jj9 }nt| jd|  |j	}t
j||| _xBtt| jD ]0}| j| }t|tr|j}|j||| j|< qW n|jr6t| j| t
jdj||S | jrPt| jd|  n|jrt| jt|jjkrt| jd|  nxt| jt|jjk rt| jd| d	 xLtt | j|jjD ]4\}\}}t|tr|j}|j|j|| j|< qW || _n*|j!r| j"||S t#| _t| jd|  | S )
NzCannot coerce list to type '%s'r   z4Cannot coerce non-positively multiplied list to '%s'z1Cannot coerce dynamically multiplied list to '%s')r  r   z%Cannot coerce multiplied list to '%s'zToo many members for '%s'zToo few members for '%s'r%   )$re   r-  r   r   r_  r   rr   r   rJ  rK  r   Zc_void_typer{   r   r   ro   rp   r#   r  r  r,  r^  re  rQ  r   TypecastNoder   r  r{  r{  r   r  r  r  r  r,   )	rP   rh  rg   rh   r{  rK  r  re  r  rN   rN   rO   rQ  !  sP    


"zListNode.coerce_toc             C   s   | S )NrN   )rP   rN   rN   rO   r)  "  s    zListNode.as_listc             C   s0   t | j| j| jd}t| jtr,t| j|_|S )N)r   r   )rn  rr   r   r   ro   rp   r   r   )rP   rX   rN   rN   rO   as_tuple
"  s    zListNode.as_tuplec             C   sP   | j jr@| jr(|jj| j dddd| _qL|jj| j ddd| _ntj| | d S )NFT)r  Zstaticreusable)r  r1  )r   r   rP  r  r  r   r  r  )rP   r   rN   rN   rO   r  "  s    zListNode.allocate_temp_resultc             C   s"   | j rt dd | jD | _d S )Nc             S   s   g | ]
}|j qS rN   )rp   )rW   re  rN   rN   rO   r   ""  s    z6ListNode.calculate_constant_result.<locals>.<listcomp>)r   r   r   rp   )rP   rN   rN   rO   r   "  s    z"ListNode.calculate_constant_resultc             C   s$   | j |}| jr || jj|9 }|S )N)r  r   r   )rP   r   lrN   rN   rO   r   $"  s    
zListNode.compile_time_valuec             C   s|  | j jr.x| jD ]}t| qW | j| nJ| j jr$| jr|jd |jdtj	  |jdj
tj	| jj d dt| jtj	f }nd}xvt| jD ]h\}}|j jr|jjtjdd |jd	| j |||j | j f  q|jd
| j |||j f  qW | jrx|jd |jd nT| j jrpxHt| j| j jjD ](\}}|jd| j |j|j f  qBW ntdd S )Nr  zPy_ssize_t %s;z&for ({i} = 0; {i} < {count}; {i}++) {{)r  countz+ (%d * %s)rD  rx  zStringTools.cz'memcpy(&(%s[%s%s]), %s, sizeof(%s[0]));z%s[%s%s] = %s;r   z%s.%s = %s;zList type never specified)r   re   r-  r   r  r   r   r   r   r  r   r   r{   r   r  r   r   r   r   r  r  r{  r{  r   r   )rP   r   rh   r  r  re  r  rN   rN   rO   r  *"  sB    




z ListNode.generate_operation_codeN)rR   rS   rT   r-  r   r   rP  r   r   rv   r   r   rQ  r)  r0  r  r   r   r  rN   rN   rN   rO   rN  !  s   
/rN  c               @   sb   e Zd ZdgZdZe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 )ComprehensionNodeloopTc             C   s   | j S )N)r   )rP   rg   rN   rN   rO   rv   Z"  s    zComprehensionNode.infer_typec             C   sh   | | j _| j| t| jtjrLt| jjts:t	| jj| jjjd | nt| jtj
sdt	| jd S )N)r   r  rv  ro   r5  r   _ForInStatNoder  rr  r   ForFromStatNode)rP   rg   rN   rN   rO   rw  ]"  s    
z&ComprehensionNode.analyse_declarationsc             C   s   | j j| d S )N)r5  rw  )rP   rg   rN   rN   rO   rx  g"  s    z-ComprehensionNode.analyse_scoped_declarationsc             C   s   | j s| jj|| _| S )N)rt  r5  r   )rP   rg   rN   rN   rO   r   j"  s    zComprehensionNode.analyse_typesc             C   s   | j r| jj|| _| S )N)rt  r5  r   )rP   rg   rN   rN   rO   ry  o"  s    z,ComprehensionNode.analyse_scoped_expressionsc             C   s   dS )NFrN   )rP   rN   rN   rO   r  t"  s    zComprehensionNode.may_be_nonec             C   s   | j | d S )N)r  )rP   r   rN   rN   rO   r#  w"  s    z&ComprehensionNode.generate_result_codec             C   s   | j tjkrd}n2| j tjkr$d}n | j tjkr6d}ntd| j  |jd| j ||j| j | j	f  | j
| | jj| d S )NzPyList_New(0)zPySet_New(NULL)zPyDict_New()z"illegal type for comprehension: %sz%s = %s; %s)r   r   r   r   r   r   r   r   r   rr   r=  r5  generate_execution_code)rP   r   Zcreate_coderN   rN   rO   r  z"  s    
z)ComprehensionNode.generate_operation_codec             C   s   | j j| d S )N)r5  rC  )rP   r   rN   rN   rO   rC  "  s    zComprehensionNode.annotateN)rR   rS   rT   r   r   r   rp   rv   rw  rx  r   ry  r  r#  r  rC  rN   rN   rN   rO   r4  R"  s   
r4  c               @   s<   e Zd ZdgZdZejZdd Zdd Z	dd Z
d	d
 ZdS )ComprehensionAppendNoder  Nc             C   s*   | j j|| _ | j jjs&| j j|| _ | S )N)r  r   r   re   rr  )rP   rg   rN   rN   rO   r   "  s    
z+ComprehensionAppendNode.analyse_expressionsc             C   s   | j jtkr&|jjtjdd d}n"| j jtkr8d}ntd| j j | j	j
| |j|jd|| j j | j	j f | j | j	j| | j	j| d S )NListCompAppendz
Optimize.c__Pyx_ListComp_Append	PySet_Addz'Invalid type for comprehension node: %sz%s(%s, (PyObject*)%s))r  r   r   r   r   r   r   r   r   r  r(  r   r   r   rr   r+  r1  )rP   r   ru  rN   rN   rO   r8  "  s     

z/ComprehensionAppendNode.generate_execution_codec             C   s   | j j|| d S )N)r  r3  )rP   rg   r   rN   rN   rO   r3  "  s    z5ComprehensionAppendNode.generate_function_definitionsc             C   s   | j j| d S )N)r  rC  )rP   r   rN   rN   rO   rC  "  s    z ComprehensionAppendNode.annotate)rR   rS   rT   r   r  r   r  r   r   r8  r3  rC  rN   rN   rN   rO   r9  "  s   r9  c               @   s4   e Zd ZddgZdd Zdd Zdd Zd	d
 ZdS )DictComprehensionAppendNodekey_expr
value_exprc             C   sP   | j j|| _ | j jjs&| j j|| _ | jj|| _| jjjsL| jj|| _| S )N)r>  r   r   re   rr  r?  )rP   rg   rN   rN   rO   r   "  s    

z/DictComprehensionAppendNode.analyse_expressionsc             C   s|   | j j| | jj| |j|jd| jj | j j | jj f | j | j j| | j j	| | jj| | jj	| d S )Nz0PyDict_SetItem(%s, (PyObject*)%s, (PyObject*)%s))
r>  r(  r?  r   r   r  r   rr   r+  r1  )rP   r   rN   rN   rO   r8  "  s    

z3DictComprehensionAppendNode.generate_execution_codec             C   s    | j j|| | jj|| d S )N)r>  r3  r?  )rP   rg   r   rN   rN   rO   r3  "  s    z9DictComprehensionAppendNode.generate_function_definitionsc             C   s   | j j| | jj| d S )N)r>  rC  r?  )rP   r   rN   rN   rO   rC  "  s    z$DictComprehensionAppendNode.annotateN)rR   rS   rT   r   r   r8  r3  rC  rN   rN   rN   rO   r=  "  s
   	r=  c                   sT   e Zd ZdgZdZdZdZeZd fdd	Z	dd Z
dd	 Zd
d Zdd Z  ZS )InlinedGeneratorExpressionNodegenNTc                sj   |j j}d|_|d k	rJ|tttfks,t|||_|jt	||t
j|d tt| j|fd|i| d S )NT)r  r   rA  )r  gbodyZ
is_inlinedr   r   r   r   Zinlined_comprehension_typer  r  r   retval_cnamerJ   r@  r  )rP   rr   rA  Zcomprehension_typer  rB  )rM   rN   rO   r  "  s    z'InlinedGeneratorExpressionNode.__init__c             C   s
   | j dkS )Nr`   r  r|  )r`   r  r|  )	orig_func)rP   rN   rN   rO   r  "  s    z*InlinedGeneratorExpressionNode.may_be_nonec             C   s   | j S )N)r   )rP   rg   rN   rN   rO   rv   "  s    z)InlinedGeneratorExpressionNode.infer_typec             C   s   | j j|| _ | S )N)rA  r   )rP   rg   rN   rN   rO   r   "  s    z,InlinedGeneratorExpressionNode.analyse_typesc             C   s:   |j d| j | jj |j| j | jf  | j| d S )Nz!%s = __Pyx_Generator_Next(%s); %s)r   r   rA  r   rr   r=  )rP   r   rN   rN   rO   r#   #  s    z3InlinedGeneratorExpressionNode.generate_result_code)N)rR   rS   rT   r   rD  r  r   r   r   r  r  rv   r   r#  rU   rN   rN   )rM   rO   r@  "  s   r@  c               @   sf   e Zd ZdZ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d Zdd Zdd ZdS )r
  z
    Merge a sequence of iterables into a set/list/tuple.

    The target collection is determined by self.type, which must be set externally.

    args    [ExprNode]
    r   TzConstructing Python collectionc             C   sd   |t tfkrN|rN|d jrN|d jt k	rNt|d j|d jd|d jd|d< tj	| |||d d S )Nr   T)r   r   r   )r   r   )
r   r   ry   r   rN  rr   r   r   r   r  )rP   rr   r   r   rN   rN   rO   r  #  s    &zMergedSequenceNode.__init__c             C   s   g }xV| j D ]L}|jr*|jr*|jjdkr*q|js6|jrHdd |j D }n|j}|j| qW | jtkrpt|}n"| jt	krt
|}n| jtkst|| _d S )Nr   c             s   s   | ]}|j V  qd S )N)rp   )rW   re  rN   rN   rO   rZ   ##  s    z?MergedSequenceNode.calculate_constant_result.<locals>.<genexpr>)r   ry   r   rp   r  r   r   r   r  r   r   r   r   )rP   r   rw   r~  rN   rN   rO   r   #  s    



z,MergedSequenceNode.calculate_constant_resultc                s   g }xb| j D ]X}|jr.|jr.|jj dkr.q|js:|jrP fdd|j D }n
|j }|j| qW | jtkryt|}W q t	k
r } z| j
| W Y d d }~X qX n"| jtkrt|}n| jtkst|S )Nr   c             3   s   | ]}|j  V  qd S )N)r   )rW   re  )r   rN   rO   rZ   7#  s    z8MergedSequenceNode.compile_time_value.<locals>.<genexpr>)r   ry   r   r   r  r   r   r   r  r  r   r   r   r   r   )rP   r   r   rw   r~  r   rN   )r   rO   r   /#  s$    



z%MergedSequenceNode.compile_time_valuec             C   s   f S )NrN   )rP   rg   rN   rN   rO   r   F#  s    z$MergedSequenceNode.type_dependenciesc             C   s   | j S )N)r   )rP   rg   rN   rN   rO   rv   I#  s    zMergedSequenceNode.infer_typec                sV    fdd| j D }t|dkr8|d j| jkr8|d S | jtttfksLt|| _ | S )Nc                s"   g | ]}|j  j jd qS )z2argument after * must be an iterable, not NoneType)r   rr  r  )rW   re  )rg   rN   rO   r   N#  s   z4MergedSequenceNode.analyse_types.<locals>.<listcomp>r%   r   )r   r{   r   r   r   r   r   )rP   rg   r   rN   )rg   rO   r   L#  s    

z MergedSequenceNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r  ]#  s    zMergedSequenceNode.may_be_nonec       
      C   s  |j | j | j| | jtk}t| j}t|}|j| |rF|j	s\| r|j
r|jtkr|jd| j |j f  |j| n`|jd| j |rdn|jr|jttfkrdnd|j |j| j | jf  | j| |j| |j| t }|rd}d}nd}d	}x |D  ]}|r.|j	s@|j
s@|j
r|j r| rZ|jrZ|jd xN|jD ]D}|j| |j|jd|| j |j f  |j| |j| qbW q|r|jd n
|jd |j| |j|jd|| j |j f  |j| |j| qW | jtkr|jd |jdtj| j f  |j| j t |jd| j tj|j| j | jf  | j| |jd x$t|D ]}	|jj t!j"|	  qW d S )Nz%s = %s;z%s = %s(%s); %sZ	PySet_Newr$  r%  r<  Z__Pyx_PySet_Updater;  Z__Pyx_PyList_Extendr:  
Optimize.cz
%s(%s, %s)PySet_Update
Builtins.c
ListExtendr  z"PyObject *%s = PyList_AsTuple(%s);z%s = %s; %sr   )r:  rE  )rF  rG  )rH  rE  )#r"  rr   r  r   r   rI  r   rJ  r(  r  ry   r   r   r   r   r,  r   r   r   r=  r+  r1  r  r   r  r  r   r   r  r  r|  r   r   r   r   )
rP   r   is_setr   rw   r  Zadd_funcZextend_funcre  r  rN   rN   rO   r(  `#  s    


















z+MergedSequenceNode.generate_evaluation_codec             C   s   x| j D ]}|j| qW d S )N)r   rC  )rP   r   rw   rN   rN   rO   rC  #  s    zMergedSequenceNode.annotateN)rR   rS   rT   r  r   r   r   r  r   r   r   rv   r   r  r(  rC  rN   rN   rN   rO   r
  #  s   Mr
  c               @   sJ   e Zd ZdZdgZeZdZdZdd Z	dd Z
d	d
 Zdd Zdd ZdS )SetNodez
    Set constructor.
    r   TzConstructing Python setc             C   sL   x:t t| jD ](}| j| }|j|}|j|| j|< qW t| _d| _| S )Nr%   )r  r{   r   r   rr  r   r   r   )rP   rg   r  re  rN   rN   rO   r   #  s    

zSetNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r  #  s    zSetNode.may_be_nonec             C   s   dd | j D | _d S )Nc             S   s   h | ]
}|j qS rN   )rp   )rW   re  rN   rN   rO   rx   #  s    z4SetNode.calculate_constant_result.<locals>.<setcomp>)r   rp   )rP   rN   rN   rO   r   #  s    z!SetNode.calculate_constant_resultc                sN    fdd| j D }yt|S  tk
rH } z| j| W Y d d }~X nX d S )Nc                s   g | ]}|j  qS rN   )r   )rW   re  )r   rN   rO   r   #  s    z.SetNode.compile_time_value.<locals>.<listcomp>)r   r  r  r   )rP   r   r  r   rN   )r   rO   r   #  s
    zSetNode.compile_time_valuec             C   s   x| j D ]}|j| qW | j| |jd| j |j| j | jf  | j| x@| j D ]6}|j| jd| j |j	 f  |j
| |j| qZW d S )Nz%s = PySet_New(0); %szPySet_Add(%s, %s))r   r(  r  r   r   r   rr   r=  r  r   r+  r1  )rP   r   re  rN   rN   rO   r(  #  s    


z SetNode.generate_evaluation_codeN)rR   rS   rT   r  r   r   r   r  r   r   r  r   r   r(  rN   rN   rN   rO   rJ  #  s   	rJ  c                   s   e Zd ZdgZdZdZeZdZdZ	g Z
edd Zd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Zdd Zdd Zdd Z  ZS )r  r  r%   FTc                s   |   fdd|D dS )Nc                s   g | ]\}}t  ||d qS ))r  r   )r  )rW   kr  )rr   rN   rO   r   #  s    z'DictNode.from_pairs.<locals>.<listcomp>)r  rN   )rL   rr   pairsrN   )rr   rO   
from_pairs#  s    zDictNode.from_pairsc             C   s   t dd | jD | _d S )Nc             S   s   g | ]
}|j qS rN   )rp   )rW   rw   rN   rN   rO   r   #  s    z6DictNode.calculate_constant_result.<locals>.<listcomp>)r	  r  rp   )rP   rN   rN   rO   r   #  s    z"DictNode.calculate_constant_resultc                sN    fdd| j D }yt|S  tk
rH } z| j| W Y d d }~X nX d S )Nc                s$   g | ]}|j j |jj fqS rN   )r  r   r   )rW   rw   )r   rN   rO   r   #  s   z/DictNode.compile_time_value.<locals>.<listcomp>)r  r	  r  r   )rP   r   rL  r   rN   )r   rO   r   #  s    

zDictNode.compile_time_valuec             C   s   f S )NrN   )rP   rg   rN   rN   rO   r   $  s    zDictNode.type_dependenciesc             C   s   t S )N)r   )rP   rg   rN   rN   rO   rv   $  s    zDictNode.infer_typec          
      s6   t dd} fdd| jD | _W d Q R X || _| S )NT)r  c                s   g | ]}|j  qS rN   )r   )rW   rw   )rg   rN   rO   r   $  s   z*DictNode.analyse_types.<locals>.<listcomp>)r   r  r-  )rP   rg   r.  rN   )rg   rO   r   $  s
    
zDictNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r  $  s    zDictNode.may_be_nonec                s  |j rn| j  | jjrNtj|s0t| jd|  t| j fdd| j	D dS | jj|sjt| jd|  n(|jr|| _|j
 rt| j	dkrt| jd|  n.|j
rt| j	t|jjk rt| jd| d x| j	D ]}t|jtr|jj|_|jjs t|jjd	 t|jjd
d|_qt|jj}|jj|}|sVt|jjd||f  q|j}t|trn|j}|j|j |_qW ntt| j| S | S )Nz-Cannot interpret struct as non-dict type '%s'c                s,   g | ]$}t |j|jj |jj d qS ))r  r   )r  rr   r  rr  r   )rW   rw   )rg   rN   rO   r   $  s   z&DictNode.coerce_to.<locals>.<listcomp>)r  z"Cannot interpret dict as type '%s'r%   z<Exactly one field must be specified to convert to union '%s'z%Not all members given for struct '%s'zInvalid struct field identifierz<error>)r   zstruct '%s' has no field '%s')re   release_errorsr   r  r   r_  r   rr   r  r  r  r{   r{  r{  r   ro   r  r^  re  r  r  rk   r   r  rQ  rJ   )rP   rh  rg   rw   r  r  r   )rM   )rg   rO   rQ  $  s@    



zDictNode.coerce_toc             C   s"   x| j D ]}t| qW g | _ d S )N)r-  r   )rP   rh   rN   rN   rO   rN  =$  s    zDictNode.release_errorszConstructing Python dictc             C   s  |j | j | j| | jj}|rf| j  |jd| j t| j	|j
| j | jf  | j| d }n| jj}t }d }d}x| j	D ]}|j| |r| jr|jd|jj   |j}| jr~|d k	r.|jsd }nT|j|krd }nD|t|jk	r"|d krt|j}|j|j nd }n|j|j |d kr~|jd| j |j f  d}|jd|j |j|jf  |jd |j| jd| j |jj |jj f  | jr|d kr|jd	 | jrR|jd	 n|t|jj}|j|}	|	d k	std
| |	j}
|jj }|jjjr:|jd| j |
||f  n|jd| j |
|f  |j| |j| qW |r|jj t!j"dd d S )Nz%%s = __Pyx_PyDict_NewPresized(%d); %sFz	if (%s) {z(if (unlikely(PyDict_Contains(%s, %s))) {Tz2__Pyx_RaiseDoubleKeywordsError("function", %s); %sz} else {zPyDict_SetItem(%s, %s, %s)r   zAstruct member %s not found, error was not handled during coercionzmemcpy(%s.%s, %s, sizeof(%s));z%s.%s = %s;r  zFunctionArguments.c)#r"  rr   r  r   re   rN  r   r   r{   r  r   r=  r{  r  r(  exclude_null_valuesr   r   r  r  r  r  r   r  rk   r  r   r   r   r+  r1  r   r   r   r   )rP   r   Zis_dictZstruct_scopeZ	keys_seenZkey_typeZneeds_error_helperrw   r  r  Z	key_cnamevalue_cnamerN   rN   rO   r(  D$  s    













z!DictNode.generate_evaluation_codec             C   s   x| j D ]}|j| qW d S )N)r  rC  )rP   r   rw   rN   rN   rO   rC  $  s    zDictNode.annotatec             C   s   t dd | jD S )Nc             S   s   g | ]\}}|j |fqS rN   )r   )rW   r  r   rN   rN   rO   r   $  s    z+DictNode.as_python_dict.<locals>.<listcomp>)r	  r  )rP   rN   rN   rO   as_python_dict$  s    zDictNode.as_python_dict)rR   rS   rT   r   r   rO  r   r   r  r  r-  r  rM  r   r   r   rv   r   r  rQ  rN  r   r(  rC  rQ  rU   rN   rN   )rM   rO   r  #  s(   	&Sr  c               @   sH   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d Z
dS )r  r  r   Nc             C   s   | j j| jjf| _d S )N)r  rp   r   )rP   rN   rN   rO   r   $  s    z&DictItemNode.calculate_constant_resultc             C   s<   | j j|| _ | jj|| _| j j|| _ | jj|| _| S )N)r  r   r   rr  )rP   rg   rN   rN   rO   r   $  s
    zDictItemNode.analyse_typesc             C   s   | j j| | jj| d S )N)r  r(  r   )rP   r   rN   rN   rO   r(  $  s    z%DictItemNode.generate_evaluation_codec             C   s   | j j| | jj| d S )N)r  r+  r   )rP   r   rN   rN   rO   r+  $  s    z#DictItemNode.generate_disposal_codec             C   s   | j j| | jj| d S )N)r  r1  r   )rP   r   rN   rN   rO   r1  $  s    zDictItemNode.free_tempsc             C   s   t | j| jgS )N)rI  r  r   )rP   rN   rN   rO   __iter__$  s    zDictItemNode.__iter__)rR   rS   rT   r   r  r   r   r(  r+  r1  rR  rN   rN   rN   rO   r  $  s   r  c               @   s6   e Zd ZdgZdZdd Zdd Zdd Zd	d
 ZdS )SortedDictKeysNodere  Tc             C   s   t j| |j|d tj| _d S )N)re  )r   r  rr   r   r   r   )rP   re  rN   rN   rO   r  $  s    zSortedDictKeysNode.__init__c             C   s,   | j j|}|jtjkr"|jd}|| _ | S )Nz!'NoneType' object is not iterable)re  r   r   r   r   r  )rP   rg   re  rN   rN   rO   r   $  s    z SortedDictKeysNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r  $  s    zSortedDictKeysNode.may_be_nonec             C   s  | j j }| j jtjkrJ|jd| j ||j| j | jf  | j	| n|j
jtjdd |jtjd}|jd| j |||j| j | jf  | j	| |jd| j   | j|d| j   |j|j| j | j | j	| |jd |j| jd	| j   d S )
Nz%s = PyDict_Keys(%s); %sZPyObjectCallMethod0zObjectHandling.ckeysz+%s = __Pyx_PyObject_CallMethod0(%s, %s); %sz"if (unlikely(!PyList_Check(%s))) {zPySequence_List(%s)r   zPyList_Sort(%s))re  r   r   r   r   r   r   r   rr   r=  r   r   r   r   rE  r	   r  r5  r  )rP   r   Zdict_resultZ
keys_cnamerN   rN   rO   r#  $  s(    






z'SortedDictKeysNode.generate_result_codeN)	rR   rS   rT   r   r   r  r   r  r#  rN   rN   rN   rO   rS  $  s   rS  c               @   s   e Zd Zdd Zdd ZdS )ModuleNameMixinc             C   s   |j | jddS )NT)r  )r  rg  )rP   r   rN   rN   rO   get_py_mod_name$  s    zModuleNameMixin.get_py_mod_namec             C   s   |j | jddS )NT)r  )r  qualname)rP   r   rN   rN   rO   get_py_qualified_name$  s    z%ModuleNameMixin.get_py_qualified_nameN)rR   rS   rT   rV  rX  rN   rN   rN   rO   rU  $  s   rU  c               @   sF   e Zd ZdgZeZdZdd Zdd Zdd Z	d	d
 Z
dZdd ZdS )	ClassNodedocTc             C   s   d S )NrN   )rP   rg   rN   rN   rO   r   %  s    zClassNode.analyse_annotationsc             C   s   t S )N)r   )rP   rg   rN   rN   rO   rv   %  s    zClassNode.infer_typec             C   s8   | j r"| j j|| _ | j j|| _ |jtjdd | S )NZCreateClasszObjectHandling.c)rZ  r   rr  r   r   r   )rP   rg   rN   rN   rO   r   %  s
    zClassNode.analyse_typesc             C   s   dS )NTrN   )rP   rN   rN   rO   r  %  s    zClassNode.may_be_nonezConstructing Python classc             C   s   | j }|j| j}| jrH|j| jd|jj |jtj	d| jj f  | j
|}| j|}|jd| j |jj |jj ||||j| j | jf  | j| d S )NzPyDict_SetItem(%s, %s, %s)r  z.%s = __Pyx_CreateClass(%s, %s, %s, %s, %s); %s)class_def_noderE  rf   rZ  r  rr   r	  r   r	   r  rV  rX  r   r   basesr   r=  )rP   r   r[  r   py_mod_namerW  rN   rN   rO   r#  %  s*    


zClassNode.generate_result_codeN)rR   rS   rT   r   r   r   r   r   rv   r   r  r   r#  rN   rN   rN   rO   rY  $  s   
rY  c               @   sH   e Zd Zg ZeZdZdZdd Zdd Z	dd Z
d	Zd
d Zdd ZdS )Py3ClassNodeFTc             C   s   t S )N)r   )rP   rg   rN   rN   rO   rv   H%  s    zPy3ClassNode.infer_typec             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   L%  s    zPy3ClassNode.analyse_typesc             C   s   dS )NTrN   )rP   rN   rN   rO   r  O%  s    zPy3ClassNode.may_be_nonezConstructing Python classc             C   s   ddl m} | jj}dd |jj D }|rt||d}t|tj	dd}|j
|jpd|j|jt||_t|||d}|j| | jjjjd	| d S )
Nr%   )AnnotationWriterc             S   s2   g | ]*}|j rt|jt|j|jd |j jdqS ))r   )r  r   )r  r  rr   r   rf   string)rW   r   rN   rN   rO   r   X%  s   z4Py3ClassNode.analyse_annotations.<locals>.<listcomp>)r  __annotations__)rf   )rB  r|   r   )AutoDocTransformsr_  r[  rr   r}  r  r  rP  r	   r  r  rf   r  r   r   r*   rw  bodyr  insert)rP   rg   r_  position
dict_itemsannotations_dictrB  rt   rN   rN   rO   r   T%  s    
z Py3ClassNode.analyse_annotationsc             C   s   |j jtjdd |j| j}| j}|jr6|jj nd}|j	rL|j	j }n| j
rXd}nd}|jd| j |||jj |jj || j| j|j| j | jf	  | j| d S )NZPy3ClassCreatezObjectHandling.cr  z((PyObject*)&PyType_Type)z$((PyObject*)&__Pyx_DefaultClassType)z9%s = __Pyx_Py3ClassCreate(%s, %s, %s, %s, %s, %d, %d); %s)r   r   r   r   rE  rf   r[  mkwr   	metaclass
force_typer   r   r\  r	  Zcalculate_metaclassZallow_py2_metaclassr   rr   r=  )rP   r   r   r[  rh  ri  rN   rN   rO   r#  h%  s*    z!Py3ClassNode.generate_result_codeN)rR   rS   rT   r   r   r   rj  r   rv   r   r  r   r   r#  rN   rN   rN   rO   r^  7%  s   r^  c               @   s(   e Zd Zg Zdd Zdd Zdd ZdS )PyClassMetaclassNodec             C   s   t | _d| _| S )NT)r   r   r   )rP   rg   rN   rN   rO   r   %  s    z"PyClassMetaclassNode.analyse_typesc             C   s   dS )NTrN   )rP   rN   rN   rO   r  %  s    z PyClassMetaclassNode.may_be_nonec             C   s   | j j}| j j}|r>|jjtjdd d|j |j f }n |jjtjdd d|j  }|jd| j ||j	| j | j
f  | j| d S )NZPy3MetaclassGetzObjectHandling.cz__Pyx_Py3MetaclassGet(%s, %s)ZCalculateMetaclassz"__Pyx_CalculateMetaclass(NULL, %s)z%s = %s; %s)r[  r\  rh  r   r   r   r   r   r   r   rr   r=  )rP   r   r\  rh  callrN   rN   rO   r#  %  s"    
z)PyClassMetaclassNode.generate_result_codeN)rR   rS   rT   r   r   r  r#  rN   rN   rN   rO   rk  %  s   rk  c               @   s*   e Zd ZdgZdd Zdd Zdd ZdS )	PyClassNamespaceNoderZ  c             C   s*   | j r| j j|j|| _ t| _d| _| S )Nr%   )rZ  r   rr  r   r   r   )rP   rg   rN   rN   rO   r   %  s
    z"PyClassNamespaceNode.analyse_typesc             C   s   dS )NTrN   )rP   rN   rN   rO   r  %  s    z PyClassNamespaceNode.may_be_nonec       
      C   s   |j | j}| j|}| j|}| j}d}| jr:| jj n|}|jrN|jj n|}|j	rb|j	j n|}	|j
d| j |	|jj ||||||j| j | jf	  | j| d S )Nz(PyObject *) NULLz>%s = __Pyx_Py3MetaclassPrepare(%s, %s, %s, %s, %s, %s, %s); %s)rE  rf   rV  rX  r[  rZ  r   rh  r   ri  r   r\  r   rr   r=  )
rP   r   r   r]  rW  r[  nullZdoc_coderh  ri  rN   rN   rO   r#  %  s(    

z)PyClassNamespaceNode.generate_result_codeN)rR   rS   rT   r   r   r  r#  rN   rN   rN   rO   rm  %  s   rm  c               @   s4   e Zd ZdZeZg ZdZdd Zdd Z	dd Z
d	S )
ClassCellInjectorNodeTFc             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   %  s    z)ClassCellInjectorNode.analyse_expressionsc             C   s<   | j s
t|jd| j |j| j | jf  | j| d S )Nz%s = PyList_New(0); %s)	is_activer   r   r   r   rr   r=  )rP   r   rN   rN   rO   r#  %  s    
z*ClassCellInjectorNode.generate_result_codec             C   s<   | j s
t|jjtjdd |j| jd| j |f  d S )NZCyFunctionClassCellzCythonFunction.cz&__Pyx_CyFunction_InitClassCell(%s, %s))	rp  r   r   r   r   r   r  rr   r   )rP   r   Zclassobj_cnamerN   rN   rO   generate_injection_code%  s
    

z-ClassCellInjectorNode.generate_injection_codeN)rR   rS   rT   r   r   r   r   rp  r   r#  rq  rN   rN   rN   rO   ro  %  s   ro  c               @   s,   e Zd Zg ZdZdZeZdd Zdd Z	dS )ClassCellNodeTFc             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   %  s    zClassCellNode.analyse_typesc             C   sj   | j s |jd| j tjf  n|jd| j tjf  |jd| j |j| jf  |j| j t	 d S )Nz&%s = __Pyx_CyFunction_GetClassObj(%s);z%s =  %s->classobj;zTif (!%s) { PyErr_SetString(PyExc_SystemError, "super(): empty __class__ cell"); %s })
is_generatorr   r   r   
self_cnamegenerator_cnamer   rr   r  r   )rP   r   rN   rN   rO   r#  %  s    z"ClassCellNode.generate_result_codeN)
rR   rS   rT   r   r   rs  r   r   r   r#  rN   rN   rN   rO   rr  %  s   rr  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ZeZdZdZdZed	d
 Zdd Zdd Zdd ZdZdd Zdd Zdd Zdd ZdS )PyCFunctionNodecode_objectdefaults_tupledefaults_kwdictrg  NFr   r%   c             C   s&   | |j ||jj|p|j|jt|dS )N)r  pymethdef_cnamebindingspecialized_cpdefsrw  )rr   r   rz  r|  CodeObjectNode)rL   rt   r{  rN   rN   rO   from_defnode!&  s    zPyCFunctionNode.from_defnodec             C   s   | j r| j| | S )N)r{  analyse_default_args)rP   rg   rN   rN   rO   r   *&  s    
zPyCFunctionNode.analyse_typesc             C   s  g }g }g }g }g }|j p&| jjo&|j}x| jjD ]}|jr|s|jjrtt|j|j|_|jj	r|jj
|j	||_n$d|_|j	jr|j| n
|j| |jj	r|jj	j|r|jr|j| n
|j| |jr2|jj||_|j|j|j|jjf q2W xN| jj| jjfD ]:}|r|jr|jj||_|j|j|j|jjf qW | jj}	|	r|	j|| j_|j|	jtjd|	jf |s|r|j }
|
jtj}tj|}g | _xP|D ]H}|j	}|j r|j!}|j"|j|dtj#|j dd}| jj||f qW x@|D ]8}|j"|j|j	dtj#|j ddd}| jj||f qW |
j$dd|dd|d	}|| _%t&|| _'x&| jD ]\}}d
tj(|j)f |_*qrW | j%j| j_%|s|r| j%dkr|rt+| jdd |D d}|j|j,|| _-|rt.| jdd |D d}|j|| _/n| j0s|r2t1| j|| j%}n
t2| j}|rTt3| j|| j%}n
t2| j}t4j5| jg ddt4j6| jt7t+| j||gdddtjdd}|j }
|j8|
 |j9|
}|j:j9|j;|_:d|_<d|_=|| j_>|rt.| jdd |D d}|j|| _?dS )zB
        Handle non-literal function's default arguments.
        TreturnN)allow_pyobjectF)r  Zallow_memoryviewstructr%   )r   z%s->%sc             S   s   g | ]
}|j qS rN   )r\   )rW   re  rN   rN   rO   r   &  s    z8PyCFunctionNode.analyse_default_args.<locals>.<listcomp>)r   c             S   s*   g | ]"}t |jt|j|jd |jdqS ))r   )r  r   )r  rr   r   rf   r\   )rW   re  rN   rN   rO   r   &  s   )r  )r  r   __defaults__)r   r  r  rc  Z
decoratorsrf   c             S   s(   g | ] \}}}t |t||d |dqS ))r   )r  r   )r  r   )rW   rr   rf   r   rN   rN   rO   r   &  s   )@r  r  Z
is_wrapperr  r   r\   r   DefaultLiteralArgNoderr   r   rQ  Z
is_dynamicre   r   r  Zkw_onlyr  r   rf   r`  r  r  Zreturn_type_annotationr	   r  r  next_idr   Zdefaults_struct_prefixr   ZStructOrUnionScopedefaultsr-  r   r  Z
arg_prefixZdeclare_struct_or_uniondefaults_structr{   defaults_pyobjectsZdynamic_args_cnamer   ra  rn  rr  rx  r  ry  r|  DefaultsTupleNoder[  DefaultsKwDictNoder   ZDefNodeZReturnStatNoder   rw  r   rc  local_scopepy_wrapper_requiredpymethdef_requireddefaults_getterrg  )rP   rg   Znonliteral_objectsZnonliteral_otherZdefault_argsZdefault_kwargsannotationsZmust_use_constantsre  r  r  r   r{  r   r   rx  ry  r  rg  rN   rN   rO   r  /&  s    















z$PyCFunctionNode.analyse_default_argsc             C   s   dS )NFrN   )rP   rN   rN   rO   r  &  s    zPyCFunctionNode.may_be_nonezConstructing Python functionc             C   s   dS )Nr  rN   )rP   rN   rN   rO   closure_result_code&  s    z#PyCFunctionNode.closure_result_codec             C   s    | j r| j| n
| j| d S )N)r{  generate_cyfunction_codegenerate_pycfunction_code)rP   r   rN   rN   rO   r#  &  s    z$PyCFunctionNode.generate_result_codec          	   C   sH   | j |}|jd| j | j| j ||j| j | jf  | j| d S )Nz'%s = PyCFunction_NewEx(&%s, %s, %s); %s)rV  r   r   rz  r  r   rr   r=  )rP   r   r]  rN   rN   rO   r  &  s    
z)PyCFunctionNode.generate_pycfunction_codec       
      C   s  | j r| j d }n| j}| j s$| jr>|jjtjdd d}n|jjtjdd d}| jrh| jj }nd}g }|j	r|j
d n|jr|j
d	 |jjjr|jj r|j
d
 |jr|j
d |rdj|}nd}|jd| j || j|| j|| j | j|tj||j| j | jf
  | j| |jr~|js>t d|jd }|j!| j t" |jd|j#j | j f  | j$| | j%r|jd| j | j&j'| j(|j)| jf  d| j&j'| j f }x,| j%D ]"\}}	|j*|d||	j+f d qW | j,r|jd| j | j,j f  | j s| j-r@|jd| j | j-j f  |j.rd|jd| j |j.jj/f  | j0r|jd| j | j0j f  d S )Nr   ZFusedFunctionzCythonFunction.cZ__pyx_FusedFunction_NewZCythonFunctionZ__Pyx_CyFunction_Newr  Z__Pyx_CYFUNCTION_STATICMETHODZ__Pyx_CYFUNCTION_CLASSMETHODZ__Pyx_CYFUNCTION_CCLASSZ__Pyx_CYFUNCTION_COROUTINEz | r  z(%s = %s(&%s, %s, %s, %s, %s, %s, %s); %szpyclass_stack is emptyr%   zPyList_Append(%s, %s);z:if (!__Pyx_CyFunction_InitDefaults(%s, sizeof(%s), %d)) %sz!__Pyx_CyFunction_Defaults(%s, %s)z%s->%s)r  z*__Pyx_CyFunction_SetDefaultsTuple(%s, %s);z+__Pyx_CyFunction_SetDefaultsKwDict(%s, %s);z+__Pyx_CyFunction_SetDefaultsGetter(%s, %s);z,__Pyx_CyFunction_SetAnnotationsDict(%s, %s);rl  )1r|  r  is_specializationr   r   r   r   rw  r   Zis_staticmethodr   Zis_classmethodr  r  r  r   Zis_anonymousis_coroutiner  r   r   rz  rX  r  rV  r   rR  r   rr   r=  Zrequires_classobjZpyclass_stackr   r  r   Z
class_cellr@  r  r  rf   r  r   r.  r   rx  ry  r  r  rg  )
rP   r   r  r  Zcode_object_resultflagsZ
class_noder  re  r   rN   rN   rO   r  &  s    





z(PyCFunctionNode.generate_cyfunction_code)rR   rS   rT   r   rw  r{  r  r  r  r  rx  ry  rg  r   r   r   r|  r  r  r~  r   r  r  r   r  r#  r  r  rN   rN   rN   rO   rv  &  s2   	 rv  c               @   s   e Zd ZdZdZdd ZdS )InnerFunctionNodeTc             C   s   | j rdtj S dS )Nz((PyObject*)%s)r  )needs_closure_coder   cur_scope_cname)rP   rN   rN   rO   r  +'  s    
z%InnerFunctionNode.closure_result_codeN)rR   rS   rT   r{  r  r  rN   rN   rN   rO   r  %'  s   r  c               @   s<   e Zd ZdgZdZdZdd Zdd Zddd	Zd
d Z	dS )r}  varnamesFNc             C   sT   t j| |j|d t|j}dd |jjD }t|jdd || D ddd| _d S )N)r  c             S   s   g | ]}|j r|qS rN   )rf   )rW   re  rN   rN   rO   r   ?'  s    z+CodeObjectNode.__init__.<locals>.<listcomp>c             S   s   g | ]}t |j|jd qS ))r   )r   rr   rf   )rW   re  rN   rN   rO   r   B'  s   r   r%   )r   r   r   )	r   r  rr   r   r   r  r{  rn  r  )rP   r  r   
local_varsrN   rN   rO   r  ;'  s    

zCodeObjectNode.__init__c             C   s   dS )NFrN   )rP   rN   rN   rO   r  G'  s    zCodeObjectNode.may_be_nonec             C   s"   | j d kr|jtddd| _ | j S )Ncodeobjr2   )r~  )r  r  r   )rP   r   rN   rN   rO   r   J'  s    
z$CodeObjectNode.calculate_result_codec             C   sl  | j d kr|jtddd| _ |j| j }|d kr4d S |j| j | j}|j|jdd|jd}t	j
|jd j jdd}|j|ddd	}d
dg}| jjr|jd | jjr|jd | jjr|jd n&| jjr|jd n| jjr|jd |jd| j t|j|j |j|jt| jjdj|p&dtjtjtj| jj tjtj||| jd tj|j| j | jf  d S )Nr  r2   )r~  TF)r  r  r   r   utf8)r  r  ZCO_OPTIMIZEDZCO_NEWLOCALS
CO_VARARGSCO_VARKEYWORDSCO_ASYNC_GENERATORCO_COROUTINECO_GENERATORzc%s = (PyObject*)__Pyx_PyCode_New(%d, %d, %d, %d, 0, %s, %s, %s, %s, %s, %s, %s, %s, %s, %d, %s); %s|r  r%   )r  r  r   r  r"  rr   r  r  rf   r	   r  Zget_filenametable_entryr  r  r   r  Zis_asyncgenr  rs  r   r{   r   r  Znum_posonly_argsr  r  r   Zempty_bytesr*  r   r   )rP   r   r  	func_name	file_pathZfile_path_constr  rN   rN   rO   r#  O'  sP    




z#CodeObjectNode.generate_result_code)N)
rR   rS   rT   r   r   r  r  r  r   r#  rN   rN   rN   rO   r}  1'  s   
r}  c                   sH   e Zd Zg ZdZdZ fddZdd Zdd Zd	d
 Z	dd Z
  ZS )r  TFc                s2   t t| j| || _|j| _| jj| _d| _d S )NF)rJ   r  r  re  rp   r   	evaluated)rP   rr   re  )rM   rN   rO   r  '  s
    
zDefaultLiteralArgNode.__init__c             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   '  s    z#DefaultLiteralArgNode.analyse_typesc             C   s   d S )NrN   )rP   r   rN   rN   rO   r#  '  s    z*DefaultLiteralArgNode.generate_result_codec             C   s   | j s| jj| d| _ d S )NT)r  re  r(  )rP   r   rN   rN   rO   r(  '  s    z.DefaultLiteralArgNode.generate_evaluation_codec             C   s   | j j| jj S )N)r   r  re  r   )rP   rN   rN   rO   r   '  s    zDefaultLiteralArgNode.result)rR   rS   rT   r   r   r   r  r   r#  r(  r   rU   rN   rN   )rM   rO   r  '  s   r  c                   s8   e Zd Zg Z fddZdd Zdd Zdd Z  ZS )	DefaultNonLiteralArgNodec                s    t t| j| || _|| _d S )N)rJ   r  r  re  r  )rP   rr   re  r  )rM   rN   rO   r  '  s    z!DefaultNonLiteralArgNode.__init__c             C   s   | j j| _d| _| S )NF)re  r   r   )rP   rg   rN   rN   rO   r   '  s    
z&DefaultNonLiteralArgNode.analyse_typesc             C   s   d S )NrN   )rP   r   rN   rN   rO   r#  '  s    z-DefaultNonLiteralArgNode.generate_result_codec             C   s"   d| j jtj| j j| jjjf S )Nz%__Pyx_CyFunction_Defaults(%s, %s)->%s)r  rf   r   rt  r|  re  r   )rP   rN   rN   rO   r   '  s    
zDefaultNonLiteralArgNode.result)	rR   rS   rT   r   r  r   r#  r   rU   rN   rN   )rM   rO   r  '  s
   r  c                   s*   e Zd Z fddZd fdd	Z  ZS )r  c                sP   g }x2|D ]*}|j js$t|||}n|j }|j| q
W tt| j||d d S )N)r   )r\   r   r  r   rJ   r  r  )rP   rr   r  r  r   re  )rM   rN   rO   r  '  s    
zDefaultsTupleNode.__init__Fc                s   t t| j||j|S )N)rJ   r  r   rr  )rP   rg   r  )rM   rN   rO   r   '  s    zDefaultsTupleNode.analyse_types)F)rR   rS   rT   r  r   rU   rN   rN   )rM   rO   r  '  s   
r  c                   s   e Zd Z fddZ  ZS )r  c                sl   g }xN|D ]F}t |j|jd}|jjs4t|||}n|j}|jt|j||d q
W tt	| j
||d d S )N)r   )r  r   )r  )r   rr   rf   r\   r   r  r   r  rJ   r  r  )rP   rr   r  r  r~  re  rf   )rM   rN   rO   r  '  s    
zDefaultsKwDictNode.__init__)rR   rS   rT   r  rU   rN   rN   )rM   rO   r  '  s   r  c                   s@   e Zd ZdgZejdZdd Z fddZ fddZ	  Z
S )	
LambdaNoder  z<lambda>c             C   sb   t | drd S |jd | _| j_d| j_d| j_d| j_| jj| | jjj	| _	|j
| j d S )Nlambda_namelambdaT)rm  r  r  r  Zno_assignment_synthesisr  is_cyfunctionrw  r   rz  Zadd_lambda_def)rP   rg   rN   rN   rO   rw  '  s    
zLambdaNode.analyse_declarationsc                s   | j j|| _ tt| j|S )N)r  r   rJ   r  r   )rP   rg   )rM   rN   rO   r   '  s    zLambdaNode.analyse_typesc                s    | j j| tt| j| d S )N)r  r8  rJ   r  r#  )rP   r   )rM   rN   rO   r#  '  s    zLambdaNode.generate_result_code)rR   rS   rT   r   r	   r  rf   rw  r   r#  rU   rN   rN   )rM   rO   r  '  s
   

r  c                   sV   e Zd ZejdZdZejdg Zej	dg Z	 fddZ
 fddZdd	 Z  ZS )
GeneratorExpressionNodegenexprFcall_parametersc                s"   t t| j|f|| g | _d S )N)rJ   r  r  r  )rP   rr   r   r  )rM   rN   rO   r  
(  s    z GeneratorExpressionNode.__init__c                s   t | drd S |jd| _tt| j| d| j_d| j_d| j_	t
j| jj_t| jtjrt| jjtsnt| jjjd | nt| jtjstd S )Ngenexpr_namer  F)rm  r  r  rJ   r  rw  r  r  r  r  r.   Zpyfunction_noargsr   rj  ro   r5  r   r6  r  rr  r   rv  r7  )rP   rg   )rM   rN   rO   rw  (  s    
z,GeneratorExpressionNode.analyse_declarationsc             C   s`   | j  gdd | jD  }dj|}|jd| j | jjj||j| j | j	f  | j
| d S )Nc             S   s   g | ]}|j  qS rN   )r   )rW   cprN   rN   rO   r   #(  s    z@GeneratorExpressionNode.generate_result_code.<locals>.<listcomp>z, z%s = %s(%s); %s)r  r  r  r   r   r  r   r  r   rr   r=  )rP   r   Zargs_to_callrN   rN   rO   r#  !(  s    
z,GeneratorExpressionNode.generate_result_code)rR   rS   rT   r	   r  rf   r{  r  r   r   r  rw  r#  rU   rN   rN   )rM   rO   r  '  s   	
r  c               @   sR   e Zd ZdgZe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S )YieldExprNodere  r   Fyieldc             C   s\   | j  s| jr&| jr&t| jd| j  d| _| jd k	rX| jj|| _| jj	j
sX| j| | S )Nz'%s' not supported herer%   )	label_numis_yield_fromin_async_genr   rr   expr_keywordr   re  r   r   re   coerce_yield_argument)rP   rg   rN   rN   rO   r   =(  s    


zYieldExprNode.analyse_typesc             C   s   | j j|| _ d S )N)re  rr  )rP   rg   rN   rN   rO   r  G(  s    z#YieldExprNode.coerce_yield_argumentc             C   sp   | j rT| j j| | j j| |jdtj| j jtf  | j j| | j j	| n|j
tjt | j| d S )Nz%s = %s;)re  r(  r  r   r   rC  r   r   r,  r1  Zput_init_to_py_nonegenerate_yield_code)rP   r   rN   rN   rO   r(  J(  s    z&YieldExprNode.generate_evaluation_codec             C   sx  |j | jjdd\}}|j| g }|jjj  x||jj D ]n\}}}|jjj|}|j	|||f |j
r|jjtjdd d| }n|j|| |jdtj||f  q>W |jtjt |jjd }	|jjd }
|	s|
r|jtj|jj d	 |j  |jjd
k	r|jdtj  n|jdtj  |jd| jr>dnd| jrLdndf  |jdtj|f  | jr| j r|jdtj  n|jdtj  |j| x|D ]z\}}}dtj|f }|j
rd| }|jd||f  |jr|jd|  |j|| n|j r|jd||f  qW | j!|tj" | j#rt| j$| |j%d| j& tj"f  |j'| j& t d
S )z
        Generate the code to return the argument in 'Naming.retval_cname'
        and to continue at the yield label.
         r  r)  zCppSupport.cppz__PYX_STD_MOVE_IF_SUPPORTED(%s)z%s->%s = %s;profile	linetrace)r   Nz"__Pyx_Coroutine_SwapException(%s);z+__Pyx_Coroutine_ResetAndClearException(%s);z*/* return from %sgenerator, %sing value */zasync rD  awaitr  z%s->resume_label = %d;z,return __Pyx__PyAsyncGenValueWrapperNew(%s);z
return %s;z%s->%sz%s = %s;z%s = 0;z"%s.memview = NULL; %s.data = NULL;z	%s = %s; )(Znew_yield_labelr  replaceZ	use_labelr  Zclosure_tempsresetZtemps_in_user  r   r   r   r   r   r   rA  r   r   r  rC  r   r_   Zput_trace_returnr  Zput_finish_refcount_contextZcurrent_exceptru  r  is_awaitr  re   r>  r   !generate_sent_value_handling_codeZsent_value_cnamer  r  r  r   r  )rP   r   r  Z
label_nameZsavedr   r   r  Z
save_cnamer  r  rN   rN   rO   r  X(  s`    



z!YieldExprNode.generate_yield_codec             C   s   |j |j|| j d S )N)r   r   rr   )rP   r   rP  rN   rN   rO   r  (  s    z/YieldExprNode.generate_sent_value_handling_codeN)rR   rS   rT   r   r   r   r  r  r  r  r  r   r  r(  r  r  rN   rN   rN   rO   r  .(  s   
Ar  c               @   s.   e Zd Zdd ZdddZdd Zd	d
 ZdS )_YieldDelegationExprNodec             C   s
   t  d S )N)NotImplementedError)rP   r   rN   rN   rO   yield_from_func(  s    z(_YieldDelegationExprNode.yield_from_funcNFc             C   s   |d kr| j j| |jdtj| j|tj|d kr<| j j n|f  |d krh| j j| | j j	| n|rx|j
|t |jtjt |jdtj  | j| |jd | jr| j| n
| j| |jd d S )Nz%s = %s(%s, %s);zif (likely(%s)) {z} else {r   )re  r(  r   r   rC  r  ru  r   r+  r1  r*  r   r>  r  r  fetch_iteration_resulthandle_iteration_exception)rP   r   r  r  rN   rN   rO   r(  (  s(    


z1_YieldDelegationExprNode.generate_evaluation_codec             C   s6   |j d| j   |j| jd| j   | j| d S )Nz
%s = NULL;z(__Pyx_PyGen_FetchStopIterationValue(&%s))r   r   r  rr   r=  )rP   r   rN   rN   rO   r  (  s    z/_YieldDelegationExprNode.fetch_iteration_resultc             C   sB   |j d |j d |j d |j d|j| j  |j d d S )Nz8PyObject* exc_type = __Pyx_PyErr_CurrentExceptionType();zif (exc_type) {zif (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear();zelse %sr   )r   r   rr   )rP   r   rN   rN   rO   r  (  s
    


z3_YieldDelegationExprNode.handle_iteration_exception)NF)rR   rS   rT   r  r(  r  r  rN   rN   rN   rO   r  (  s   
r  c               @   s$   e Zd ZdZdZdd Zdd ZdS )YieldFromExprNodeTz
yield fromc             C   s(   | j jjst| jd | j j|| _ d S )Nz-yielding from non-Python object not supported)re  r   r$  r   rr   rr  )rP   rg   rN   rN   rO   r  (  s    
z'YieldFromExprNode.coerce_yield_argumentc             C   s   |j jtjdd dS )NZGeneratorYieldFromzCoroutine.cZ__Pyx_Generator_Yield_From)r   r   r   r   )rP   r   rN   rN   rO   r  (  s    z!YieldFromExprNode.yield_from_funcN)rR   rS   rT   r  r  r  r  rN   rN   rN   rO   r  (  s   r  c               @   s$   e Zd ZdZdZdd Zdd ZdS )AwaitExprNodeTr  c             C   s   | j d k	r| j j|| _ d S )N)re  rr  )rP   rg   rN   rN   rO   r  (  s    
z#AwaitExprNode.coerce_yield_argumentc             C   s   |j jtjdd dS )NZCoroutineYieldFromzCoroutine.cZ__Pyx_Coroutine_Yield_From)r   r   r   r   )rP   r   rN   rN   rO   r  (  s    zAwaitExprNode.yield_from_funcN)rR   rS   rT   r  r  r  r  rN   rN   rN   rO   r  (  s   r  c                   s,   e Zd Zdd Z fddZdd Z  ZS )AwaitIterNextExprNodec             C   sJ   |j jtjdd |jd |jd |jd |jd |jd d S )NStopAsyncIterationzCoroutine.cz8PyObject* exc_type = __Pyx_PyErr_CurrentExceptionType();zif (unlikely(exc_type && (exc_type == __Pyx_PyExc_StopAsyncIteration || ( exc_type != PyExc_StopIteration && exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, __Pyx_PyExc_StopAsyncIteration))))) {zPyErr_Clear();zbreak;r   )r   r   r   r   r   )rP   r   rN   rN   rO   _generate_break(  s    



z%AwaitIterNextExprNode._generate_breakc                s,   |j std| j| tt| j| d S )Nz1AwaitIterNextExprNode outside of 'async for' loop)break_labelr   r  rJ   r  r  )rP   r   )rM   rN   rO   r  (  s    
z,AwaitIterNextExprNode.fetch_iteration_resultc             C   sF   |j std|jd|  | j| |j|j| j |jd d S )Nz1AwaitIterNextExprNode outside of 'async for' loopzif (unlikely(!%s)) {r   )r  r   r   r  r   rr   )rP   r   rP  rN   rN   rO   r   )  s
    
z7AwaitIterNextExprNode.generate_sent_value_handling_code)rR   rS   rT   r  r  r  rU   rN   rN   )rM   rO   r  (  s   
r  c               @   s0   e Zd ZeZdZdd ZdZdd Zdd Z	d	S )
GlobalsExprNoder%   c             C   s   |j tj | S )N)r   r   Zglobals_utility_code)rP   rg   rN   rN   rO   r   )  s    zGlobalsExprNode.analyse_typeszConstructing globals dictc             C   s   dS )NFrN   )rP   rN   rN   rO   r  )  s    zGlobalsExprNode.may_be_nonec             C   s2   |j d| j |j| j | jf  | j| d S )Nz%s = __Pyx_Globals(); %s)r   r   r   rr   r=  )rP   r   rN   rN   rO   r#  )  s    z$GlobalsExprNode.generate_result_codeN)
rR   rS   rT   r   r   r   r   r   r  r#  rN   rN   rN   rO   r  	)  s   r  c               @   s   e Zd Zdd ZdS )LocalsDictItemNodec             C   sR   | j j|| _ | jj|| _| j j|| _ | jjj|rH| jj|| _nd | _| S )N)r  r   r   rr  r   r  )rP   rg   rN   rN   rO   r   )  s    z LocalsDictItemNode.analyse_typesN)rR   rS   rT   r   rN   rN   rN   rO   r  )  s   r  c                   s$   e Zd Zdd Z fddZ  ZS )FuncLocalsExprNodec                s@   t dd |jj D } fdd|D }tj|  |dd d S )Nc             S   s   g | ]}|j r|j qS rN   )rf   )rW   r   rN   rN   rO   r   ,)  s    z/FuncLocalsExprNode.__init__.<locals>.<listcomp>c          
      s,   g | ]$}t  t |d t |dddqS ))r   T)rf   rH  )r  r   )r  r   rP  )rW   r  )rr   rN   rO   r   -)  s   T)r  rO  )r|  r}  r  r  r  )rP   rr   rg   r  r~  rN   )rr   rO   r  *)  s    

zFuncLocalsExprNode.__init__c                s&   t t| j|}dd |jD |_|S )Nc             S   s   g | ]}|j d k	r|qS )N)r   )rW   r  rN   rN   rO   r   6)  s    z4FuncLocalsExprNode.analyse_types.<locals>.<listcomp>)rJ   r  r   r  )rP   rg   rt   )rM   rN   rO   r   4)  s    z FuncLocalsExprNode.analyse_types)rR   rS   rT   r  r   rU   rN   rN   )rM   rO   r  ))  s   
r  c               @   s4   e Zd Zdd Zdd Zdd Zdd Zd	d
 ZdS )PyClassLocalsExprNodec             C   s   t j| | || _d S )N)r  r  pyclass_dict)rP   rr   r  rN   rN   rO   r  <)  s    zPyClassLocalsExprNode.__init__c             C   s   | j j| _d| _| S )NF)r  r   r   )rP   rg   rN   rN   rO   r   @)  s    
z#PyClassLocalsExprNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r  E)  s    z!PyClassLocalsExprNode.may_be_nonec             C   s
   | j j S )N)r  r   )rP   rN   rN   rO   r   H)  s    zPyClassLocalsExprNode.resultc             C   s   d S )NrN   )rP   r   rN   rN   rO   r#  K)  s    z*PyClassLocalsExprNode.generate_result_codeN)rR   rS   rT   r  r   r  r   r#  rN   rN   rN   rO   r  ;)  s
   r  c             C   s*   |j rt| S |jr t| |jS t| |S )N)r  r  r  r  r	  r  )rr   Z
scope_noderg   rN   rN   rO   LocalsExprNodeO)  s
    r  )not~r  r   c               @   s   e Zd Z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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$S )&UnopNoder  TFc             C   s   t | j }|| jj| _d S )N)compile_time_unary_operatorsr
   r  rp   )rP   r  rN   rN   rO   r   t)  s    
z"UnopNode.calculate_constant_resultc             C   sh   t j| j}|s"t| jd| j  | jj|}y||S  tk
rb } z| j| W Y d d }~X nX d S )Nz3Unary '%s' not supported in compile-time expression)	r  r^   r
   r   rr   r  r   r  r   )rP   r   r  r  r   rN   rN   rO   r   x)  s    
zUnopNode.compile_time_valuec             C   s<   | j j|}|js|jr0|j| j}|d k	r0|S | j||S )N)r  rv   r   rJ  find_cpp_operation_typer
   infer_unop_type)rP   rg   operand_typecpp_typerN   rN   rO   rv   )  s    zUnopNode.infer_typec             C   s   |j r
tS |S d S )N)re   r   )rP   rg   r  rN   rN   rO   r  )  s    zUnopNode.infer_unop_typec             C   s,   | j jr"| j jjr"| j jtk	r"dS tj| S )NF)r  r   r
  r   r   r  )rP   rN   rN   rO   r  )  s    zUnopNode.may_be_nonec             C   sx   | j j|| _ | j|r6tt| j| j j| _d| _n>| j rV| j	| t
| _d| _n| j rj| j| n
| j| | S )Nr%   )r  r   is_pythran_operationrE   r<   r
   r   r   is_py_operationcoerce_operand_to_pyobjectr   is_cpp_operationanalyse_cpp_operationanalyse_c_operation)rP   rg   rN   rN   rO   r   )  s    


zUnopNode.analyse_typesc             C   s
   | j j S )N)r  r   )rP   rN   rN   rO   r   )  s    zUnopNode.check_constc             C   s   | j jjp| j jjS )N)r  r   re   r  )rP   rN   rN   rO   r  )  s    zUnopNode.is_py_operationc             C   s    t |}| jj}|o|jp|jS )N)r=   r  r   r-  r9   )rP   rg   Z
np_pythranop_typerN   rN   rO   r  )  s    zUnopNode.is_pythran_operationc             C   s   | j  r| j  d S )N)r  r  )rP   rg   rN   rN   rO   r  )  s    zUnopNode.nogil_checkc             C   s   | j j}|jS )N)r  r   r   )rP   r   rN   rN   rO   r  )  s    zUnopNode.is_cpp_operationc             C   s   | j j|| _ d S )N)r  rr  )rP   rg   rN   rN   rO   r  )  s    z#UnopNode.coerce_operand_to_pyobjectc             C   s   | j jrL|jd |jd| j   |jd| j | j | j| jj f  n| jj jrb| j| nx| j	r| j
 r| jdkrt|| jd| j | j| jj f | j jr| j nd | j| j n |jd| j | j| jj f  d S )Nz// Pythran unaryopz__Pyx_call_destructor(%s);znew (&%s) decltype(%s){%s%s};r   z%s = %s %s;)r   r9   r   r   r
   r  r   re   generate_py_operation_coder   r  r   r   rr   r   r  )rP   r   rN   rN   rO   r#  )  s"    

zUnopNode.generate_result_codec             C   sF   | j |}|jd| j || jj |j| j | jf  | j| d S )Nz%s = %s(%s); %s)py_operation_functionr   r   r  r   r   rr   r=  )rP   r   ru  rN   rN   rO   r  )  s    
z#UnopNode.generate_py_operation_codec             C   s0   | j jjs$t| jd| j| j jf  tj| _d S )Nz"Invalid operand type for '%s' (%s))r  r   rU  r   rr   r
   r   r,   )rP   rN   rN   rO   
type_error)  s    
zUnopNode.type_errorc             C   s  | j jg}| jr$| j r$|jtj |j| j| j	|}|rL| rL| j
  d S |r|jj| _|jj| _| jdkrd| _t| r|jtjdd nd| _d| _| jr| j r| j jj| j	tjd}n| j jj| j	}|o|d krt| jd| j	tf  | j
  d S || _d S )Nr   Tr  zCppSupport.cpprD  )r  z '%s' operator not defined for %s)r  r   is_inc_dec_op	is_prefixr   r   r  r  rr   r
   r  r   r   r   r   r   r   r   r  r   )rP   rg   overload_checkZoperand_typesr   r  rN   rN   rO   r  )  s4    




zUnopNode.analyse_cpp_operationN)T)rR   rS   rT   r   infixr  r   r   rv   r  r  r   r   r  r  r  r  r  r#  r  r  r  rN   rN   rN   rO   r  d)  s&   
r  c               @   s>   e Zd ZdZejZdd Zdd Zdd Z	dd	 Z
d
d ZdS )NotNode!c             C   s   | j j | _d S )N)r  rp   )rP   rN   rN   rO   r   	*  s    z!NotNode.calculate_constant_resultc             C   sD   | j j|}y| S  tk
r> } z| j| W Y d d }~X nX d S )N)r  r   r  r   )rP   r   r  r   rN   rN   rO   r   *  s
    zNotNode.compile_time_valuec             C   s   t jS )N)r   rx  )rP   rg   r  rN   rN   rO   r  *  s    zNotNode.infer_unop_typec             C   s:   | j j|| _ | j j}|jr(| j| n| j j|| _ | S )N)r  r   r   r   r  r   )rP   rg   r  rN   rN   rO   r   *  s    zNotNode.analyse_typesc             C   s   d| j j  S )Nz(!%s))r  r   )rP   rN   rN   rO   r   *  s    zNotNode.calculate_result_codeN)rR   rS   rT   r
   r   rx  r   r   r   r  r   r   rN   rN   rN   rO   r  *  s   	r  c               @   s(   e Zd ZdZdd Zdd Zdd ZdS )	UnaryPlusNoder   c             C   s   t j| jjt j| _d S )N)r   r  r  r   r  )rP   rg   rN   rN   rO   r  (*  s    z!UnaryPlusNode.analyse_c_operationc             C   s   dS )NZPyNumber_PositiverN   )rP   r   rN   rN   rO   r  ,*  s    z#UnaryPlusNode.py_operation_functionc             C   s$   | j  rd| jj  S | jj S d S )Nz(+%s))r  r  r   )rP   rN   rN   rO   r   /*  s    z#UnaryPlusNode.calculate_result_codeN)rR   rS   rT   r
   r  r  r   rN   rN   rN   rO   r  #*  s   r  c               @   s0   e Zd ZdZdd Zdd Zdd Zdd	 Zd
S )UnaryMinusNoder  c             C   sN   | j jjr tj| j jtj| _n| j jjr4tj| _n| j  | jjrJd| _	d S )NF)
r  r   r  r   r  r  rw  r  rb  r  )rP   rg   rN   rN   rO   r  ;*  s    


z"UnaryMinusNode.analyse_c_operationc             C   s   dS )NZPyNumber_NegativerN   )rP   r   rN   rN   rO   r  F*  s    z$UnaryMinusNode.py_operation_functionc             C   s4   | j rd| jj  S d| jjjd| jj f S d S )Nz(-%s)z%s(%s)r  )r  r  r   r   unary_op)rP   rN   rN   rO   r   I*  s    z$UnaryMinusNode.calculate_result_codec             C   s   | j j }|rd| S d S )Nz(-%s))r  r   )rP   r   rN   rN   rO   r   O*  s    
z)UnaryMinusNode.get_constant_c_result_codeN)rR   rS   rT   r
   r  r  r   r   rN   rN   rN   rO   r  6*  s
   r  c               @   s$   e Zd Zdd Zdd Zdd ZdS )	TildeNodec             C   s@   | j jjr tj| j jtj| _n| j jjr4tj| _n| j  d S )N)r  r   r\  r   r  r  rw  r  )rP   rg   rN   rN   rO   r  W*  s    


zTildeNode.analyse_c_operationc             C   s   dS )NZPyNumber_InvertrN   )rP   r   rN   rN   rO   r  `*  s    zTildeNode.py_operation_functionc             C   s   d| j j  S )Nz(~%s))r  r   )rP   rN   rN   rO   r   c*  s    zTildeNode.calculate_result_codeN)rR   rS   rT   r  r  r   rN   rN   rN   rO   r  T*  s   	r  c               @   s   e Zd Zdd ZdS )	CUnopNodec             C   s   dS )NFrN   )rP   rN   rN   rO   r  i*  s    zCUnopNode.is_py_operationN)rR   rS   rT   r  rN   rN   rN   rO   r  g*  s   r  c               @   s(   e Zd ZdZdd Zdd Zdd ZdS )	DereferenceNoder   c             C   s   |j r|jS tjS d S )N)rJ  rK  r   r,   )rP   rg   r  rN   rN   rO   r  q*  s    zDereferenceNode.infer_unop_typec             C   s>   | j jjr2|jr$tj| j jj| _q:| j jj| _n| j  d S )N)r  r   rJ  Zis_cppr   r  rK  r  )rP   rg   rN   rN   rO   r  w*  s
    
z#DereferenceNode.analyse_c_operationc             C   s   d| j j  S )Nz(*%s))r  r   )rP   rN   rN   rO   r   *  s    z%DereferenceNode.calculate_result_codeN)rR   rS   rT   r
   r  r  r   rN   rN   rN   rO   r  l*  s   	r  c               @   s(   e Zd ZdZdd Zdd Zdd ZdS )	DecrementIncrementNodeTc             C   sV   | j jjsJ| jr,t| jd| j| j jf  nt| jd| j| j| j jf  tj| _d S )Nz0No match for 'operator%s' (operand type is '%s')zENo 'operator%s(int)' declared for postfix '%s' (operand type is '%s'))	r  r   rU  r  r   rr   r
   r   r,   )rP   rN   rN   rO   r  *  s    
z!DecrementIncrementNode.type_errorc             C   sB   | j jjr tj| j jtj| _n| j jjr6| j j| _n| j  d S )N)r  r   r  r   r  r  rJ  r  )rP   rg   rN   rN   rO   r  *  s    

z*DecrementIncrementNode.analyse_c_operationc             C   s2   | j rd| j| jj f S d| jj | jf S d S )Nz(%s%s))r  r
   r  r   )rP   rN   rN   rO   r   *  s    z,DecrementIncrementNode.calculate_result_codeN)rR   rS   rT   r  r  r  r   rN   rN   rN   rO   r  *  s   
	r  c                s    fddS )Nc                s   t | f d|S )N)r  r
   )r  )rr   r  )r  r
   rN   rO   <lambda>*  s    z%inc_dec_constructor.<locals>.<lambda>rN   )r  r
   rN   )r  r
   rO   inc_dec_constructor*  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 )AmpersandNoder  c             C   s
   t j|S )N)r   
c_ptr_type)rP   rg   r  rN   rN   rO   r  *  s    zAmpersandNode.infer_unop_typec             C   s   | j j|| _ | j j}|jr*| j|dd |jp>|jp>| j j sd|jrR| j	d n| j	d|  | S |j
r| j	d| j jrd| j j n| j jrd| j j nd  | S |j s| j rtj|| _| S )	NF)r  z'Cannot take address of memoryview slicez&Taking address of non-lvalue (type %s)z Cannot take address of Python %szvariable '%s'zobject attribute '%s'r$  )r  r   r   r   r  r   r   r   r   r   re   r   rf   r  rt  r   r  )rP   rg   ZargtyperN   rN   rO   r   *  s$    zAmpersandNode.analyse_typesc             C   s
   | j j S )N)r  r	  )rP   rN   rN   rO   r   *  s    zAmpersandNode.check_constc             C   s   t | j| tj| _d| _d S )Nz<error>)r   rr   r   r,   r   r  )rP   messrN   rN   rO   r   *  s    zAmpersandNode.errorc             C   s   d| j j  S )Nz(&%s))r  r   )rP   rN   rN   rO   r   *  s    z#AmpersandNode.calculate_result_codec             C   sV   | j jjrR| jdkrRt|| jd| j | j| j j f | jjrD| j nd | j	| j
 d S )Nr   z%s = %s %s;)r  r   r   r   r   rr   r   r
   re   r   r  )rP   r   rN   rN   rO   r#  *  s
    z"AmpersandNode.generate_result_codeN)
rR   rS   rT   r
   r  r   r   r   r   r#  rN   rN   rN   rO   r  *  s   r  )r   r  r  c             C   s   t |tr6|dkr6t|jttj|j |j|jdS t |t	rp|j
|  koTdkn  rpt| d|fd  d t| | ||dS )Nr  )rr   r   r  r  z+-zAPython has no increment/decrement operator: %s%sx == %s(%sx) == x      )r
   r  )ro   r   rr   rk   r   r  r   r  r  r  r
   r   unop_node_classes)rr   r
   r  rN   rN   rO   	unop_node*  s    $r  c               @   s   e Zd ZdgZd Z Z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dZdd Zdd Zdd ZdS )r/  r  Nc             C   s   f S )NrN   )rP   rg   rN   rN   rO   r   *  s    zTypecastNode.type_dependenciesc             C   s0   | j d kr*| jj|}| jj||\}| _ | j S )N)r   rK  r  
declarator)rP   rg   rK  r  rN   rN   rO   rv   *  s    
zTypecastNode.infer_typec             C   s  | j d kr*| jj|}| jj||\}| _ | jj r<| j  | j jrXt| j	d t
j| _ | jj|| _| j t
jkr~| jj|S | j j}| jj j}|r| r| jj r| j j r| j j rt| j	d |o| r|| j tkr| jj jrt| j|S | jj j|rt| _| jj| j || _n^| jj jrP| jj jjp>| jj jjsjt| j	d nt| j	d| jj | j f  | jj|| _n|r| r| j j|r| jj| j || _nJ| j jr| j jjp| j jjst| j	d nt| j	d| j | jj f  n|rF|rF| j r$t!| j| j |dd| _n t"| jt#r| jj| j || _nD| j j$rl| jj j$rl| jj|| _n| jj j%r| jj| j || _| j jr| j jjr| j jj&r| jj }|jr|j}|jr|j& rt| j	dd	 | S )
NzCannot cast to a function typez>Casting temporary Python object to non-numeric non-Python typez>Python objects cannot be cast from pointers of primitive typesz8No conversion from %s to %s, python object pointer used.z<Python objects cannot be cast to pointers of primitive typesT)notnonezQCasting a GIL-requiring function into a nogil function circumvents GIL validationr%   )'r   rK  r  r  r  r~   r   r   r   rr   r   r,   r   rx  r   re   r   r  r   r   r\  r]  r  r   r   rQ  rJ  r  r  r   r   create_from_py_utility_codeZ	typecheckr`  ro   rS  rb  r   r   )rP   rg   rK  r  Zto_pyZfrom_pyr  rN   rN   rO   r    +  sl    



"zTypecastNode.analyse_typesc             C   s
   | j j S )N)r  r  )rP   rN   rN   rO   r  @+  s    zTypecastNode.is_simplec             C   s
   | j j S )N)r  r   )rP   rN   rN   rO   r   D+  s    zTypecastNode.is_ephemeralc             C   s   | j p| jj S )N)r   r  r   )rP   rN   rN   rO   r   H+  s    z!TypecastNode.nonlocally_immutablec             C   s    | j r| j jr| jr| j  d S )N)r   re   r   r  )rP   rg   rN   rN   rO   r  K+  s    zTypecastNode.nogil_checkc             C   s
   | j j S )N)r  r   )rP   rN   rN   rO   r   O+  s    zTypecastNode.check_constc             C   s   | j | jj| _d S )N)r   r  rp   )rP   rN   rN   rO   r   R+  s    z&TypecastNode.calculate_constant_resultc             C   s   |d kr| j j }| jjr| j j }| j jjr`| jjj| j jj|}| jjj| j jj|}n| jjj|}d}d| jj||f S | jj|S d S )Nr  z
%s(%s, %s))	r  r   r   rb  	real_typer  	real_code	imag_coder  )rP   operand_result	real_part	imag_partrN   rN   rO   r   U+  s     


z"TypecastNode.calculate_result_codec             C   s   | j j }|r| jj|S d S )N)r  r   r   r  )rP   r  rN   rN   rO   r   i+  s    
z'TypecastNode.get_constant_c_result_codec             C   s,   | j jr| j r| jj|S tj| |S d S )N)r   re   r   r  r   r   )rP   r   rN   rN   rO   r   n+  s    zTypecastNode.result_asc             C   s:   | j r6|jd| j | jj f  |j| j | j  d S )Nz%s = (PyObject *)%s;)r   r   r   r  r  r   )rP   r   rN   rN   rO   r#  u+  s    z!TypecastNode.generate_result_code)N)rR   rS   rT   r   rK  r  r   r   rv   r   r  r   r   r  r   r   r   r   r   r#  rN   rN   rN   rO   r/  *  s   @
r/  zStart may not be givenz'Stop must be provided to indicate shapezVStrides may only be given to indicate contiguity. Consider slicing it after conversionz2Can only create cython.array from pointer or arrayz7Pointer base type does not match cython.array base typec               @   sb   e Zd ZdZddgZdZdZdZdZe	j
Zdd Zd	d
 Zdd Zdd Zdd Zedd ZdS )rS  an  
    Used when a pointer of base_type is cast to a memoryviewslice with that
    base type. i.e.

        <int[:M:1, :N]> p

    creates a fortran-contiguous cython.array.

    We leave the type set to object so coercions to object are more efficient
    and less work. Acquiring a memoryviewslice from this will be just as
    efficient. ExprNode.coerce_to() will do the additional typecheck on
    self.compile_time_type

    This also handles <int[:, :]> my_c_array


    operand             ExprNode                 the thing we're casting
    base_type_node      MemoryViewSliceTypeNode  the cast expression node
    r  shapesNTcc             C   s,  ddl m} | jj|| _| jr(| j}n| jjj|}| jj}t| _	g | _
t|}| jj	}| jj	j r| jj	j rt| jjt | S g }|jrx@|jr|j|j |j}qW n"|jr|j}nt| jd|  | S |j|p|jst| jjt | S | jj	jr*t||kr*t| jjd|t|f  | S xxt|D ]j\}}	|	jjs\t|	jjt | S |	jjr|r|| }
t| jt|
|
tjd|	_nt|	jt  | S |	jj||	_|	jj!| j"|}|j#s|j$| | j
j| |d|d fk}|	j%j rz|rz|	j%j||	_%|	j%j	j& rD|	j%j#rD|	j%j	j' rDt|	j%jd | S |	j%j(|dkrht|	j%jt) | S |dkrd| _*n&|	j%j r6| r6t|	j%jt) | S q6W | jj+s| jj$|| _dgt| }| j*dkrd|d< nd|d< tj,||| _-| j-j.| j | j/|| _	|j0| |j1|j2 | S )Nr%   )rE  zunexpected base type %s foundz/Expected %d dimensions, array has %d dimensions)r   rp   r   r   zExpected an integer literalZfortranr9  followcontig)r9  r  )r9  r  )r9  r  rl  )3rD  rE  r  r   array_dtypebase_type_noder  r  r,   r   r  r{   rJ  r   r   rr   ERR_NOT_POINTERr   ra  rK  rM  r  ERR_BASE_TYPEr  r   rZ  	ERR_STARTr   r   rk   r   r  ERR_NOT_STOPrQ  
shape_typer   r  r   r\  rU  r   	ERR_STEPSmoder   r  rO  Zvalidate_memslice_dtypeget_cython_array_typeZuse_cython_array_utility_coder   Ztypeinfo_to_format_code)rP   rg   rE  r  r  r  rK  Zarray_dimension_sizesZaxis_noZaxisZdimsizeshapeZfirst_or_lastrN   rN   rO   r   +  s    







zCythonArrayNode.analyse_typesc             C   s$   | j rtd|jj| jd| _ d S )Nztemp allocated multiple timesT)r   r  r  r  r   )rP   r   rN   rN   rO   r  ,  s    z$CythonArrayNode.allocate_temp_resultc             C   s
   | j |S )N)r  )rP   rg   rN   rN   rO   rv   ,  s    zCythonArrayNode.infer_typec             C   s"   |j  jj}|j  |jjdjS )Narray)r  r  cython_scopeZload_cythonscopeZ	viewscoper|  r   )rP   rg   r  rN   rN   rO   r  ,  s    z%CythonArrayNode.get_cython_array_typec                sj  ddl m} fddjD }jj} jjtd} jjtd}d|j  }|j	 |}j
jjr jdj
j    jd  j jj
j  jd	  jd
|| j|jf   j|t dt| }	 jd||	dj| j|jf   j|t  jdj |||jj
j  jj jf  j   fdd}
|
| |
| d S )Nr%   )r+  c                s   g | ]} j j|j qS rN   )r  r  r   )rW   r  )rP   rN   rO   r   ,  s   z8CythonArrayNode.generate_result_code.<locals>.<listcomp>Tz
sizeof(%s)z
if (!%s) {zQPyErr_SetString(PyExc_ValueError,"Cannot create cython.array from NULL pointer");r   z(%s = __pyx_format_from_typeinfo(&%s); %sz __PYX_BUILD_PY_SSIZE_T z.%s = Py_BuildValue((char*) "(" %s ")", %s); %sz, zS%s = __pyx_array_new(%s, %s, PyBytes_AS_STRING(%s), (char *) "%s", (char *) %s); %sc                s    j | t  jj|  d S )N)r*  r   r  r  )r8  )r   rN   rO   disposeE,  s    z5CythonArrayNode.generate_result_code.<locals>.dispose)rD  r+  r  rO  rY  r  r  r   r  Zget_type_information_cnamer  r   rJ  r   r   r   rr   r   r:  r{   r  r  r=  )rP   r   r+  r  rY  Zshapes_tempZformat_tempitemsize	type_infoZbuildvalue_fmtr  rN   )r   rP   rO   r#  ,  sB    





z$CythonArrayNode.generate_result_codec       	      C   s   |j }|j}t|}g }x&|jr>|jt||||d |j}qW t|ddd|d _t	j
|||d}t||||d}|j|}|S )	z@
        Given a C array type, return a CythonArrayNode
        )r   r   r   r   T)r   r  r%   )r  r  )r  r  r  rl  )rr   r   r[  r   r   r  rK  r   r   r   ZMemoryViewSliceTypeNoderS  r   )	rL   Zsrc_noderg   rr   rK  rg  r  Zmemslicenoder   rN   rN   rO   rT  L,  s    



zCythonArrayNode.from_carray)rR   rS   rT   r  r   r  r   r  r  r   r   r  r   r  rv   r  r#  r  rT  rN   rN   rN   rO   rS  +  s   h2rS  c               @   s"   e Zd ZejZdd Zdd ZdS )
SizeofNodec             C   s   dS )NTrN   )rP   rN   rN   rO   r   i,  s    zSizeofNode.check_constc             C   s   d S )NrN   )rP   r   rN   rN   rO   r#  l,  s    zSizeofNode.generate_result_codeN)rR   rS   rT   r   r-  r   r   r#  rN   rN   rN   rO   r  d,  s   r  c               @   s,   e Zd Zg ZdZdd Zdd Zdd ZdS )r  Nc       
      C   s   dr| j jr| j j}|j|d }|jd krt| j|d d}x$|dd  D ]}t| j||d}qLW t| j|| j jd}t| j|dj	|}|S | j
d kr| j j|}| jj||\}}	|	| _
| j  | S )Nr   )rr   rf   r%   )rr   rs  rt  )r  )rK  module_pathr|  r"  rP  rr   r~  rf   SizeofVarNoder   r  r  r  
check_type)
rP   rg   r  rs  r  rA  rt   rK  r  r  rN   rN   rO   r   y,  s     

zSizeofTypeNode.analyse_typesc             C   sZ   | j }|sd S |jr*|j r*t| jd n,|jr>t| jd n|j sVt| jd|  d S )Nz Cannot take sizeof Python objectzCannot take sizeof voidz'Cannot take sizeof incomplete type '%s')r  re   r	  r   rr   r  is_complete)rP   r  rN   rN   rO   r  ,  s    zSizeofTypeNode.check_typec             C   s,   | j jr| j jddd}n
| j j }d| S )NrD  r%   )Zderefz(sizeof(%s)))r  r	  r   r  )rP   r  rN   rN   rO   r   ,  s    
z$SizeofTypeNode.calculate_result_code)rR   rS   rT   r   r  r   r  r   rN   rN   rN   rO   r  p,  s
   r  c               @   s*   e Zd ZdgZdd Zdd Zdd ZdS )	r  r  c             C   sx   | j j|}|rf|| _| jjrVy| jj|j| _W n" tk
rT   t| j jd Y nX t	| _
| j  n| j j|| _ | S )NzLType cannot be specialized since it is not a fused argument to this function)r  r   r  r   r   r   r&   r   rr   r  rM   r  r   )rP   rg   Zoperand_as_typerN   rN   rO   r   ,  s    
zSizeofVarNode.analyse_typesc             C   s   d| j j  S )Nz(sizeof(%s)))r  r   )rP   rN   rN   rO   r   ,  s    z#SizeofVarNode.calculate_result_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r#  ,  s    z"SizeofVarNode.generate_result_codeN)rR   rS   rT   r   r   r   r#  rN   rN   rN   rO   r  ,  s   r  c               @   sR   e Zd ZdgZdZdZdZdd ZdZdd Z	d	d
 Z
dd Zdd Zdd ZdS )
TypeidNoder  Nr%   c             C   s@   |}x|j s|j}qW |jd| j}|jd}tjtj|jS )Nzlibcpp.typeinfor  )	r  ru  find_modulerr   r|  r   r  Zc_const_typer   )rP   rg   Z
env_moduleZtypeinfo_moduleZtypeinfo_entryrN   rN   rO   get_type_info_type,  s    

zTypeidNode.get_type_info_typeztypeid operatorc             C   s   | j stj| _ | j| | j|}|s4| jd | S | jd krB| S || _ | jj|}|rl|| _d| _	d | _nl| jj
|| _d| _	d | _| jj jr| jd | S | jj jr| jd | S | jj j s| jd| jj   | S |jtjdd | S )	NzKThe 'libcpp.typeinfo' module must be cimported to use the typeid() operatorTFz$Cannot use typeid on a Python objectzCannot use typeid on voidz)Cannot use typeid on incomplete type '%s'r  zCppSupport.cpp)r   r   r,   r  r  r   r  r  r  r  r   re   r  r  r   r   r   )rP   rg   r  Zas_typerN   rN   rO   r   ,  s:    







zTypeidNode.analyse_typesc             C   s   t | j| tj| _d| _d S )Nz<error>)r   rr   r   r,   r   r  )rP   r  rN   rN   rO   r   ,  s    zTypeidNode.errorc             C   s   dS )NTrN   )rP   rN   rN   rO   r   ,  s    zTypeidNode.check_constc             C   s   | j S )N)r   )rP   rN   rN   rO   r   -  s    z TypeidNode.calculate_result_codec             C   s@   | j r| jj }n
| jj }t|| jd| j|f d d | j d S )Nz%s = typeid(%s);)r  r  r  r   r   rr   r   r  )rP   r   r  rN   rN   rO   r#  -  s    
zTypeidNode.generate_result_code)rR   rS   rT   r   r  r)  r   r  Zcpp_messager   r   r   r   r#  rN   rN   rN   rO   r  ,  s    r  c               @   sB   e Zd ZdZeZdgZdd Zdd Zdd Z	d	d
 Z
dd ZdS )
TypeofNodeNr  c             C   sH   | j j|| _ tjt| j j}t| j|d}|j|}|j|| _	| S )N)r   )
r  r   r	   r  rk   r   r  rr   rr  r  )rP   rg   r   r  rN   rN   rO   r   -  s    
zTypeofNode.analyse_typesc             C   s   | j j|| _ | j jS )N)r  r   r   )rP   rg   rN   rN   rO   r    -  s    zTypeofNode.analyse_as_typec             C   s   dS )NFrN   )rP   rN   rN   rO   r  $-  s    zTypeofNode.may_be_nonec             C   s   | j j| d S )N)r  r(  )rP   r   rN   rN   rO   r(  '-  s    z#TypeofNode.generate_evaluation_codec             C   s
   | j j S )N)r  r   )rP   rN   rN   rO   r   *-  s    z TypeofNode.calculate_result_code)rR   rS   rT   r  r   r   r   r   r   r  r(  r   rN   rN   rN   rO   r  -  s   r  c             C   s0   y
| j }W n tk
r$   |j}Y nX || |S )N)
__matmul__r}   __rmatmul__)r  br  rN   rN   rO   matmul_operator6-  s
    
r"  c             C   s   | |kS )NrN   )xseqrN   rN   rO   r  S-  s    r  c             C   s   | |kS )NrN   )r#  r$  rN   rN   rO   r  T-  s    )<z<=z==z!=z>=>rW  is_notr   r  /z//z<<%r   r  z**z>>r  ^@innot_inc             C   s&   t j| j}|s"t| jd| j  |S )Nz4Binary '%s' not supported in compile-time expression)compile_time_binary_operatorsr^   r
   r   rr   )rt   r  rN   rN   rO   get_compile_time_binopW-  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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 fd$d%Zd&d' Zd(d) Z  ZS )*	BinopNoderX  rY  Fc             C   s"   t | j }|| jj| jj| _d S )N)r.  r
   rX  rp   rY  )rP   r  rN   rN   rO   r   p-  s    
z#BinopNode.calculate_constant_resultc             C   s\   t | }| jj|}| jj|}y
|||S  tk
rV } z| j| W Y d d }~X nX d S )N)r/  rX  r   rY  r  r   )rP   r   r  rX  rY  r   rN   rN   rO   r   v-  s    
zBinopNode.compile_time_valuec             C   s   | j | jj|| jj||S )N)r  rX  rv   rY  )rP   rg   rN   rN   rO   rv   -  s    zBinopNode.infer_typec             C   s*   | j j|| _ | jj|| _| j| | S )N)rX  r   rY  r=  )rP   rg   rN   rN   rO   r   -  s    
zBinopNode.analyse_typesc             C   s   | j |r6| j| jj| jj|| _| jjs.td| _n\| j rt| j	| | j| jj| jj|| _| jj
sltd| _n| j r| j| n
| j| d S )Nr%   )r  r  rX  r   rY  r9   r   r   r  coerce_operands_to_pyobjectsre   r  r  r  )rP   rg   rN   rN   rO   r=  -  s    



zBinopNode.analyse_operationc             C   s   | j | jj| jjS )N)is_py_operation_typesrX  r   rY  )rP   rN   rN   rO   r  -  s    zBinopNode.is_py_operationc             C   s   |j p|j p|jp|jS )N)re   r  )rP   type1type2rN   rN   rO   r2  -  s    zBinopNode.is_py_operation_typesc             C   s   | j | jj| jj|S )N)is_pythran_operation_typesrX  r   rY  )rP   rg   rN   rN   rO   r  -  s    zBinopNode.is_pythran_operationc             C   s(   t |o&t|o&t|o&t|p&t|S )N)r=   r8   r9   )rP   r3  r4  rg   rN   rN   rO   r5  -  s    z$BinopNode.is_pythran_operation_typesc             C   s   | j jjp| jjjS )N)rX  r   r   rY  )rP   rN   rN   rO   r  -  s    
zBinopNode.is_cpp_operationc             C   s   |j | j| j| jg}|s&| j  d S |j}|j| _|j| _| jdkrfd| _t	| rf|j
tjdd |jrr|j}t|jdkr| jj|jd j|| _n0| jj|jd j|| _| jj|jd j|| _|j| _d S )Nr   r%   r  zCppSupport.cppr   )r  r
   rX  rY  r  r   r   r   r   r   r   r   r   rJ  rK  r{   r   rQ  r  )rP   rg   r   r  rN   rN   rO   r  -  s$    
zBinopNode.analyse_cpp_operationc             C   s   | j |||r tt| j||S | j||r|jr:tj}n|jrFtj	}|jrTtj}n|jr`tj	}|j
sl|j
r||kr| jdkr|S | j||}|d k	r|S tS |js|jrtjS | j||S d S )Nz**%+|&^)r5  rE   r;   r
   r2  r$  r   r   r%  r   r
  infer_builtin_types_operationr   rU  r   r,   compute_c_result_type)rP   r3  r4  rg   r  rN   rN   rO   r  -  s*    zBinopNode.result_typec             C   s   d S )NrN   )rP   r3  r4  rN   rN   rO   r6  -  s    z'BinopNode.infer_builtin_types_operationc             C   s   | j  r| j  d S )N)r  r  )rP   rg   rN   rN   rO   r  -  s    zBinopNode.nogil_checkc             C   s    | j j|| _ | jj|| _d S )N)rX  rr  rY  )rP   rg   rN   rN   rO   r1  -  s    z&BinopNode.coerce_operands_to_pyobjectsc             C   s   | j j o| jj S )N)rX  r   rY  )rP   rN   rN   rO   r   -  s    zBinopNode.check_constc                s"   t t| j p | jj p | jj S )N)rJ   r0  r   rX  rY  )rP   )rM   rN   rO   r   -  s    zBinopNode.is_ephemeralc          
   C   s  | j j}| jj}| jjr|jd |jd| j   | jdkrj|jd| j | j | j j | jj f  n.|jd| j | j | j j | j| jj f  n
|js|jr2| j	|}| jdkrdnd}|jr| j j
 n| j j }|jr| jj
 n| jj }|jd| j |||||j| j | jf  | j| nt| jr| j r| jd	krt|| jd
| j | j f | jjr|| j nd | j| j n|jd
| j | j f  d S )Nz// Pythran binopz__Pyx_call_destructor(%s);z**zBnew (&%s) decltype(%s){pythonic::numpy::functor::power{}(%s, %s)};z!new (&%s) decltype(%s){%s %s %s};z	, Py_NonerD  z%s = %s(%s, %s%s); %sr   z%s = %s;)rX  r   rY  r9   r   r   r
   r   re   r  r   r   rr   r=  r   r  r   r   r   r   r  )rP   r   r3  r4  ru  
extra_argsZ
op1_resultZ
op2_resultrN   rN   rO   r#  -  sL    


zBinopNode.generate_result_codec             C   s@   | j jjp| jjjs4t| jd| j| j j| jjf  tj| _d S )Nz'Invalid operand types for '%s' (%s; %s))	rX  r   rU  rY  r   rr   r
   r   r,   )rP   rN   rN   rO   r  .  s    


zBinopNode.type_error)rR   rS   rT   r   r  r   r   rv   r   r=  r  r2  r  r5  r  r  r  r6  r  r1  r   r   r#  r  rU   rN   rN   )rM   rO   r0  `-  s*   	,r0  c               @   s,   e Zd Zdd Zdd Zdd Zdd Zd	S )

CBinopNodec             C   s    t j| |}|j rtj|_|S )N)r0  r   r  r   r,   r   )rP   rg   rt   rN   rN   rO   r   &.  s    zCBinopNode.analyse_typesc             C   s   dS )NrD  rN   )rP   r   rN   rN   rO   r  ,.  s    z CBinopNode.py_operation_functionc             C   s   d| j j | j| jj f S )Nz
(%s %s %s))rX  r   r
   rY  )rP   rN   rN   rO   r   /.  s    z CBinopNode.calculate_result_codec             C   sD   d }|j s|jr|j| j|}|d kr@|j s2|jr@|j| j|}|S )N)r   rJ  r  r
   )rP   r3  r4  r  rN   rN   rO   r7  5.  s    z CBinopNode.compute_c_result_typeN)rR   rS   rT   r   r  r   r7  rN   rN   rN   rO   r9  $.  s   r9  c                s    fdd}|S )Nc                s   t | fd i|S )Nr
   )r9  )rr   r  )r
   rN   rO   make_binop_node@.  s    z,c_binop_constructor.<locals>.make_binop_noderN   )r
   r:  rN   )r
   rO   c_binop_constructor?.  s    r;  c                   s   e Zd ZdZdZdZdd Zdd Z fdd	Zd
d Z	dd Z
 fddZdd Zdd Zdd Zddddddddddd d!d"d#Zd$d%d&d'd(Z  ZS ))NumBinopNodeTFNc             C   s  | j j}| jj}| j||| _| js0| j  d S | jjr>d| _| jjr|jd r| j	| j
kr| j	dkr| j j r| jj  r| j| j  | _ | _d| _|jd | _| jj| j
| j	 || jj d| _d| _| j s|jo|jr| j j| j|| _ | jj| j|| _d S )	NFr  r   r   Tzoverflowcheck.fold)Z	const_rhs)r   r   )rX  r   rY  r7  r  rb  r  r\  r_   r
   overflow_op_namesr~   overflow_checkZoverflow_foldZoverflow_check_binopr  r   r  rQ  )rP   rg   r3  r4  rN   rN   rO   r  K.  s2    



z NumBinopNode.analyse_c_operationc             C   sN   | j ||rFtj||}|tjkr4| jdkrBtj}ntj|tj}|S d S d S )Nz|^&)c_types_okayr   r  rx  r
   r  )rP   r3  r4  widest_typerN   rN   rO   r7  f.  s    


z"NumBinopNode.compute_c_result_typec                sH   | j r| j jrdS | jj }| jj }|r:|jr:|r:|jr:dS tt| j S )NF)r   r
  rX  rY  rJ   r<  r  )rP   r3  r4  )rM   rN   rO   r  t.  s    zNumBinopNode.may_be_nonec             C   s4   | j j }| jj }|r,|r,d|| j|f S d S d S )Nz
(%s %s %s))rX  r   rY  r
   )rP   Zvalue1Zvalue2rN   rN   rO   r   .  s
    

z'NumBinopNode.get_constant_c_result_codec             C   s   |j s|jo|j p|jS )N)r  rw  )rP   r3  r4  rN   rN   rO   r?  .  s    zNumBinopNode.c_types_okayc                s   | j r0| | _|jjtjdd| _|jd| j  tt	| j
| | j r|jd| j  |jd |j|j| j |jd |jj| j d S )NF)r  z%s = 0;zif (unlikely(%s)) {z8PyErr_SetString(PyExc_OverflowError, "value too large");r   )r>  overflow_bit_noder  r  r   r  overflow_bitr   rJ   r<  r(  r   rr   r  )rP   r   )rM   rN   rO   r(  .  s    

z%NumBinopNode.generate_evaluation_codec             C   s   | j d k	r,d| j| jj | jj | j jf S | jjs:| jrt	| jr\| jj
 | jj
  }}n| jj | jj  }}d|| j|f S | jj| j}|d krt| jd| j| jf  d|| jj | jj f S d S )Nz%s(%s, %s, &%s)z
(%s %s %s)z'binary operator %s not supported for %sz
%s(%s, %s))rA  r  rX  r   rY  rB  r   r   r  r9   r   r
   	binary_opr   rr   )rP   result1result2r  rN   rN   rO   r   .  s$    

z"NumBinopNode.calculate_result_codec             C   s   |j p|j ptj| ||S )N)r  r0  r2  )rP   r3  r4  rN   rN   rO   r2  .  s    z"NumBinopNode.is_py_operation_typesc             C   s"   | j | j }| jr|jdd}|S )NZ	PyNumber_ZPyNumber_InPlace)py_functionsr
   r  r  )rP   r   r  rN   rN   rO   r  .  s    z"NumBinopNode.py_operation_functionZPyNumber_OrZPyNumber_XorZPyNumber_AndZPyNumber_LshiftZPyNumber_RshiftZPyNumber_AddZPyNumber_SubtractZPyNumber_MultiplyZ__Pyx_PyNumber_MatrixMultiplyZ__Pyx_PyNumber_DivideZPyNumber_FloorDivideZPyNumber_RemainderZPyNumber_Power)r  r*  r  z<<z>>r   r  r   r+  r(  z//r)  z**r  r2  mullshift)r   r  r   z<<)rR   rS   rT   r  r>  rA  r  r7  r  r   r?  r(  r   r2  r  rF  r=  rU   rN   rN   )rM   rO   r<  D.  s:   r<  c               @   s   e Zd Zdd ZdS )IntBinopNodec             C   s   |j s|jo|j p|jS )N)r\  rw  )rP   r3  r4  rN   rN   rO   r?  .  s    zIntBinopNode.c_types_okayN)rR   rS   rT   r?  rN   rN   rN   rO   rI  .  s   rI  c                   s4   e Zd Zdd Zdd Zdd Z fddZ  ZS )	AddNodec             C   s.   |j r|j s|jr|jrdS tj| ||S d S )Nr%   )r$  r%  r<  r2  )rP   r3  r4  rN   rN   rO   r2  .  s    zAddNode.is_py_operation_typesc             C   s<   t ttttf}||kr8||kr8|t|j||j| S d S )N)r   r   r   r/   r   r  r   )rP   r3  r4  string_typesrN   rN   rO   r6  .  s
    z%AddNode.infer_builtin_types_operationc             C   sJ   |j s|jr|js|jr|S |j s(|jr8|js4|jr8|S tj| ||S d S )N)rJ  r   r\  rw  r<  r7  )rP   r3  r4  rN   rN   rO   r7  .  s    zAddNode.compute_c_result_typec                s  | j j| jj }}d }|tks&|tkr|ttfkrD|ttfkrDd}n"t| j ts\t| jtrbd}nd}|r| jsx| j jr|j	j
tjdd d}n(|tkr|tkr|j	j
tjdd d}|r| js| j jr|d7 }| j j s| jj r|d	7 }|S tt| j|S )
NTFZUnicodeConcatInPlacezObjectHandling.cZ__Pyx_PyUnicode_ConcatZStrConcatInPlaceZ__Pyx_PyStr_ConcatZInPlaceZSafe)rX  r   rY  r   r   ro   r  r  r   r   r   r   r   r  rJ   rJ  r  )rP   r   r3  r4  r  Zis_unicode_concat)rM   rN   rO   r  .  s0    zAddNode.py_operation_function)rR   rS   rT   r2  r6  r7  r  rU   rN   rN   )rM   rO   rJ  .  s   	
rJ  c               @   s   e Zd Zdd ZdS )SubNodec             C   sL   |j s|jr|js|jr|S |j s(|jr:|j s4|jr:tjS tj| ||S d S )N)rJ  r   r\  rw  r   Zc_ptrdiff_t_typer<  r7  )rP   r3  r4  rN   rN   rO   r7  /  s    zSubNode.compute_c_result_typeN)rR   rS   rT   r7  rN   rN   rN   rO   rL  /  s   rL  c                   sd   e Zd ZdZdd Zedd Zdd Zdd	 Z fd
dZ	 fddZ
 fddZdd Z  ZS )MulNodeFc             C   s   | j j|| _ | jj|| _| j | _| jrt| j }| j}|jrV|jd krV| j|||S |jrt|jd krt| j|||S | j| | S )N)	rX  r   rY  calculate_is_sequence_mulis_sequence_mulry   r   analyse_sequence_mulr=  )rP   rg   rX  rY  rN   rN   rO   r   ,/  s    

zMulNode.analyse_typesc             C   s   | j o| tko| tk	S )N)r
  r"   r!   )r   rN   rN   rO   is_builtin_seqmul_type=/  s    zMulNode.is_builtin_seqmul_typec             C   sX   | j j}| jj}|tks|jr(|| }}|tks6|jrT|jsB|jrFdS | j|rTdS dS )NTF)rX  r   rY  r0   r\  r$  r  rQ  )rP   r3  r4  rN   rN   rO   rN  A/  s    

z!MulNode.calculate_is_sequence_mulc             C   s(   |j d kst|j|}||_ |j|S )N)r   r   rr  r   )rP   rg   r$  ZmultrN   rN   rO   rP  N/  s    
zMulNode.analyse_sequence_mulc                sP   | j r<| jjjr | jj|| _n| jjjr8| jj|| _d S tt| j| d S )N)	rO  rX  r   r  rr  rY  rJ   rM  r1  )rP   rg   )rM   rN   rO   r1  T/  s    

z$MulNode.coerce_operands_to_pyobjectsc                s   | j ptt| j||S )N)rO  rJ   rM  r2  )rP   r3  r4  )rM   rN   rO   r2  ^/  s    zMulNode.is_py_operation_typesc                s<   | j r,|jjtjdd | jjjr(dS dS tt	| j
|S )Nr+  zObjectHandling.cZ__Pyx_PySequence_MultiplyZ__Pyx_PySequence_Multiply_Left)rO  r   r   r   r   rX  r   re   rJ   rM  r  )rP   r   )rM   rN   rO   r  a/  s
    zMulNode.py_operation_functionc             C   s@   |j r(|j r(| j|r|S | j|r(|S |jr2|S |jr<|S d S )N)r
  rQ  r\  )rP   r3  r4  rN   rN   rO   r6  h/  s    

z%MulNode.infer_builtin_types_operation)rR   rS   rT   rO  r   staticmethodrQ  rN  rP  r1  r2  r  r6  rU   rN   rN   )rM   rO   rM  (/  s   
rM  c                   s$   e Zd Zdd Z fddZ  ZS )MatMultNodec             C   s   dS )NTrN   )rP   r3  r4  rN   rN   rO   r2  |/  s    z!MatMultNode.is_py_operation_typesc                s(   |j jtjdd tt| j| d S )NZMatrixMultiplyzObjectHandling.c)r   r   r   r   rJ   rS  r(  )rP   r   )rM   rN   rO   r(  /  s    z$MatMultNode.generate_evaluation_code)rR   rS   rT   r2  r(  rU   rN   rN   )rM   rO   rS  y/  s   rS  c               @   sx   e Zd ZdZdZdZdZdZdd Zdd Z	dd Z
d	d
 Zdd Zdd Zdd Zdd Zdd Zdd Zdd ZdS )DivNodeNFc             C   s>   t | j }| jdkr:| jd kr:t|tr:t|tr:t d }|S )Nr(  z//)r.  r
   truedivisionro   r#   )rP   op1op2r  rN   rN   rO   !find_compile_time_binary_operator/  s
    
z)DivNode.find_compile_time_binary_operatorc             C   s4   | j j}| jj}| j||}|| j j| jj| _d S )N)rX  rp   rY  rX  )rP   rV  rW  r  rN   rN   rO   r   /  s    z!DivNode.calculate_constant_resultc             C   s`   | j j|}| jj|}y| j||}|||S  tk
rZ } z| j| W Y d d }~X nX d S )N)rX  r   rY  rX  r  r   )rP   r   rX  rY  r  r   rN   rN   rO   r   /  s    
zDivNode.compile_time_valuec             C   s$   | j s|jd rd| _n| j| _d S )N	cdivisionF)rY  r_   ctruedivisionrU  )rP   rg   rN   rN   rO   _check_truedivision/  s    zDivNode._check_truedivisionc             C   s(   | j | | j| jj|| jj||S )N)r[  r  rX  rv   rY  )rP   rg   rN   rN   rO   rv   /  s    

zDivNode.infer_typec             C   s   | j | tj| | | j r$d| _| jjs| jd koX|jd  oX| jj	  pX| jj
dk| _| jsl|jd r| jj|| _| jj|| _d S )NTrY  r   cdivision_warnings)r[  r<  r=  r  rY  r   re   r_   rY  r~   rp   zerodivision_checkrX  r   )rP   rg   rN   rN   rO   r=  /  s    
zDivNode.analyse_operationc             C   s\   | j dkrN| jrN|j rN|j rN|j rN|j rNtj|tj}tj||}|S tj| ||S )Nr(  )	r
   rZ  r   ry  r   r  r  r<  r7  )rP   r3  r4  r@  rN   rN   rO   r7  /  s     zDivNode.compute_c_result_typec             C   s   | j jrdS dS d S )Nz"integer division or modulo by zerozfloat division)r   r\  )rP   rN   rN   rO   zero_division_message/  s    zDivNode.zero_division_messagec             C   s   | j j rp| j j rp| jd krN|jjd pJ| j jpJ| j jsB| j joJ| j j	 | _| jsp|jj
tjddj| j  tj| | | j| d S )NrY  ZDivIntzCMath.c)r   re   rb  rY  r   r_   ry  r  rw  r   r   r   r   r   r<  r(  generate_div_warning_code)rP   r   rN   rN   rO   r(  /  s    
z DivNode.generate_evaluation_codec             C   s^  | j }| jjsZ| jrl| js:d| jjd| jj f }nd| jj  }|jd|  |rb|j	  |jd| j
   |r|j  |j|j| j |jd | jjo| jjo| jdkrl|jjtjdd	 | jjjd
krd| jj  }n | jjj }d|| jj |f }|jd| jj || jj f  |r8|j	  |jd |rP|j  |j|j| j |jd |jjd rZ| jdkrZ|jjtjdd |jd| jj | jj f  dtjtjd }|rd}|jd|  |j	  |j|j| jdd |jd||f  |j  n|}|j|j| jdd |jd|  |j|j |jd d S )Nz%s(%s)Zzeroz%s == 0zif (unlikely(%s)) {z/PyErr_SetString(PyExc_ZeroDivisionError, "%s");r   r)  ZUnaryNegOverflowsz
Overflow.cr2   zunlikely(%s == -1)z+(!(((%s)-1) > 0)) && unlikely(%s == (%s)-1)z]else if (sizeof(%s) == sizeof(long) && %s  && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(%s))) {zLPyErr_SetString(PyExc_OverflowError, "value too large to perform division");r\  r(  ZCDivisionWarningzCMath.cz$if (unlikely((%s < 0) ^ (%s < 0))) {z1__Pyx_cdivision_warning(%(FILENAME)s, %(LINENO)s))ZFILENAMEZLINENOr   zint %s;T)rN  z%s = %s;zif (unlikely(%s)) )r  r   re   r]  r  r  rY  r   r   r   r^  r   r   rr   r\  r   r
   r   r   r   r   r  rX  r_   r   Zfilename_cnameZlineno_cnameZset_error_infor  r  r  )rP   r   Zin_nogilZ	zero_testZminus1_checkZtype_of_op2Zwarning_coder  rN   rN   rO   r_  /  sj    




z!DivNode.generate_div_warning_codec             C   s   | j js| j rtj| S | j jrD| jdkrDd| jj | j	j f S | j
sP| jr| jj }| j	j }| j
r| j | jj kr| j j|}| j | j	j kr| j j|}d||f S d| j j | jj | j	j f S d S )Nz//zfloor(%s / %s)z	(%s / %s)z__Pyx_div_%s(%s, %s))r   rb  r  r<  r   ry  r
   rX  r   rY  rU  rY  r  specialization_name)rP   rV  rW  rN   rN   rO   r   0  s&    


zDivNode.calculate_result_code)rR   rS   rT   rY  rU  rZ  r\  r]  rX  r   r   r[  rv   r=  r7  r^  r(  r_  r   rN   rN   rN   rO   rT  /  s    
?rT  s'   %(?:%|(?:\([^)]+\))?[-+#,0-9 ]*([a-z]))   d   i   o   u   x   X   e   E   f   F   g   G   c   b   ac                   sL   e Zd Zdd Zdd Zdd Zdd Zd	d
 Zdd Z fddZ	  Z
S )ModNodec             C   s   |j p|j ptj| ||S )N)r$  r<  r2  )rP   r3  r4  rN   rN   rO   r2  E0  s    zModNode.is_py_operation_typesc             C   s   |t kr |js| jj  r|S np|tttfkr|t kr:|S |jrD|S | jjrx|tks\|tkrtt	t
| jjtkrt|S tS |tkr|j rd S tS d S )N)r   r
  rX  r  r   r   r/   r  r  r  _find_formatting_typesr   _safe_bytes_formats)rP   r3  r4  rN   rN   rO   r6  J0  s"    z%ModNode.infer_builtin_types_operationc             C   s   | j jrdS dS d S )Nz"integer division or modulo by zerozfloat divmod())r   r\  )rP   rN   rN   rO   r^  `0  s    zModNode.zero_division_messagec             C   sf   t j| | | jjsb| jd kr4|jd p0| jj | _| j rb| jj rb| jj rbt	| j
d| j  d S )NrY  z(mod operator not supported for type '%s')rT  r=  r   re   rY  r_   r   r\  ry  r   rr   )rP   rg   rN   rN   rO   r=  f0  s    
zModNode.analyse_operationc             C   sv   | j j r\| j r\| j jr8|jjtjddj| j  n$|jjtjddj| j | j j	d t
j| | | j| d S )NZModIntzCMath.cZModFloat)math_h_modifier)r   re   rY  r\  r   r   r   r   r   rs  r<  r(  r_  )rP   r   rN   rN   rO   r(  n0  s    z ModNode.generate_evaluation_codec             C   sj   | j rF| jjr,d| jj| jj | jj f S d| jj | jj f S n d| jj | jj | jj f S d S )Nzfmod%s(%s, %s)z
(%s %% %s)z__Pyx_mod_%s(%s, %s))rY  r   ry  rs  rX  r   rY  r`  )rP   rN   rN   rO   r   {0  s    zModNode.calculate_result_codec                s   | j j| jj }}|tkrT| j j sJ|jr4|j|sJ|tkrNt| jt	 rNdS dS n@|t
kr| j j s|jrv|j|s|tkrt| jt	 rdS dS tt| j|S )NZ__Pyx_PyUnicode_FormatSafeZPyUnicode_FormatZ__Pyx_PyString_FormatSafeZ__Pyx_PyString_Format)rX  r   rY  r   r  r	  r_  r   ro   r^  r   rJ   rp  r  )rP   r   r3  r4  )rM   rN   rO   r  0  s    

zModNode.py_operation_function)rR   rS   rT   r2  r6  r^  r=  r(  r   r  rU   rN   rN   )rM   rO   rp  B0  s   rp  c                   sl   e Zd ZdZdZdd Z fddZ fddZd	d
 Z fddZ	dd Z
 fddZ fddZ  ZS )PowNodeNFc             C   s   | j d k	rd S |jd | _ d S )NZcpow)is_cpowr_   )rP   rg   rN   rN   rO   _check_cpow0  s    
zPowNode._check_cpowc                s   | j | tt| j|S )N)rv  rJ   rt  rv   )rP   rg   )rM   rN   rO   rv   0  s    
zPowNode.infer_typec                s   | j | tt| j|S )N)rv  rJ   rt  r   )rP   rg   )rM   rN   rO   r   0  s    
zPowNode.analyse_typesc             C   s   t j| | | jjrf| jjjrR| jj| j|| _| jj| j|| _| jj	d| _
qt| jd d| _
n| jjr~d| jj | _
nx| jjrd| jj jdd | _
|jtjdd	j| j
| jj | jjrd
pdd n$| jjst| jd| jj| jjf  d S )Nz**z complex int powers not supportedz<error>powz__Pyx_pow_%sr  r  ZIntPowzCMath.cr%   r   )r  r   r   z1got unexpected types for C power operator: %s, %s)r<  r  r   rb  r  ry  rX  rQ  rY  rC  pow_funcr   rr   rs  r\  r  r  r   r   r   r   r   rU  )rP   rg   rN   rN   rO   r  0  s(    
zPowNode.analyse_c_operationc                s8  ddl m} d }| jj r&| jjdkp4|jo4|jdk}|jpf| jj oft| jj|oft	| jj| jjk}d}| j
rtt| j||}| jj st| jjto| jjdk }nv|s|rtt| j||}| jj s|jo|j}|rd| _nt| jjto| jjdk }n| j||r tj}d| _|r4tj|tj}|S )Nr   )RealFT)Znumbersry  rX  r~   rp   r\  r   rY  ro   r  ru  rJ   rt  r7  r#   type_was_inferredr?  r   re  r  r  )rP   r3  r4  ry  Zc_result_typeZop1_is_definitely_positiveZtype2_is_intZneeds_widening)rM   rN   rO   r7  0  s6    




zPowNode.compute_c_result_typec                s(    fdd}d j | j| jf S )Nc                s(    j | j kr| j S  j j| j S d S )N)r   r   r  )r  )rP   rN   rO   r+   0  s    z/PowNode.calculate_result_code.<locals>.typecastz
%s(%s, %s))rx  rX  rY  )rP   r+   rN   )rP   rO   r   0  s
    zPowNode.calculate_result_codec                s`   | j jrP| jjdkrPt| jjtrP| jj tkrP|jj	t
jdd | jrLdS dS tt| j|S )Nr2   ZPyNumberPow2z
Optimize.cZ__Pyx_PyNumber_InPlacePowerOf2Z__Pyx_PyNumber_PowerOf2)r   re   rX  rp   ro   r#   rY  r   r   r   r   r   r  rJ   rt  r  )rP   r   )rM   rN   rO   r  1  s    zPowNode.py_operation_functionc       	         s   || j kr| S | jd kr| jr|js*|jr| j tjkrJd	 fdd	 d}n|jr^dd  d}ndd   | j\}} | j\}}|r|rt	| j
d|  d| _|| _|| _| j|}|j |kr|j||}|S tt| j||S )
NTc                s>   | j js| j jrd| fS |r:t| tr: | jdd| jfS dS )NTF)recurse)FN)r   ry  r\  ro   rd  re  )r  r{  )check_typesrN   rO   r|  1  s
    z&PowNode.coerce_to.<locals>.check_typesza non-complex C numeric typec             S   s   | j jrd| fS dS d S )NTF)FN)r   r\  )r  rN   rN   rO   r|  1  s    zan integer C numeric typec             S   s   dS )NF)FNrN   )r  rN   rN   rO   r|  '1  s    zTreating '**' as if 'cython.cpow(True)' since it is directly assigned to a %s. This is likely to be fragile and we recommend setting 'cython.cpow' explicitly.)T)r   ru  rz  ry  r\  r   re  rX  rY  r   rr   r   rQ  rJ   rt  )	rP   rh  rg   Z
msg_detailZ	check_op1rV  Z	check_op2rW  r   )rM   )r|  rO   rQ  1  s0    


zPowNode.coerce_to)rR   rS   rT   ru  rz  rv  rv   r   r  r7  r   r  rQ  rU   rN   rN   )rM   rO   rt  0  s   *rt  c               @   s   e Zd ZdZddg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Zdd  Zd!d" Zd#d$ Zd%d& ZdS )'BoolBinopNodeag  
    Short-circuiting boolean operation.

    Note that this node provides the same code generation method as
    BoolBinopResultNode to simplify expression nesting.

    operator  string                              "and"/"or"
    operand1  BoolBinopNode/BoolBinopResultNode   left operand
    operand2  BoolBinopNode/BoolBinopResultNode   right operand
    rX  rY  TNc             C   s$   | j j|}| jj|}tj||S )N)rX  rv   rY  r   independent_spanning_type)rP   rg   r3  r4  rN   rN   rO   rv   K1  s    zBoolBinopNode.infer_typec             C   s,   | j dkr| jj S | jj p&| jj S d S )Nor)r
   rY  r  rX  )rP   rN   rN   rO   r  P1  s    

zBoolBinopNode.may_be_nonec             C   s4   | j j}| jj}| jdkr&|o || _n
|p,|| _d S )Nand)rX  rp   rY  r
   )rP   rX  rY  rN   rN   rO   r   V1  s
    
z'BoolBinopNode.calculate_constant_resultc             C   s6   | j j|}| jj|}| jdkr*|o(|S |p0|S d S )Nr  )rX  r   rY  r
   )rP   r   rX  rY  rN   rN   rO   r   ^1  s
    
z BoolBinopNode.compile_time_valuec             C   s   | j j p| jj S )N)rX  r   rY  )rP   rN   rN   rO   r   f1  s    zBoolBinopNode.is_ephemeralc             C   sJ   | j j|}| jj|}tj|j|j| _| j||| _ | j||| _| S )N)rX  r   rY  r   r~  r   _wrap_operand)rP   rg   rX  rY  rN   rN   rO   r   i1  s    zBoolBinopNode.analyse_typesc             C   s    t |ttfst|| j|}|S )N)ro   r}  BoolBinopResultNoder   )rP   r  rg   rN   rN   rO   r  u1  s    zBoolBinopNode._wrap_operandc             C   s$   | j | j|| _| j | j|| _dS )z
        Must get called by transforms that want to create a correct BoolBinopNode
        after the type analysis phase.
        N)r  rX  rY  )rP   rg   rN   rN   rO   wrap_operandsz1  s    zBoolBinopNode.wrap_operandsc             C   s   | j tj|S )N)rQ  r   rx  )rP   rg   rN   rN   rO   r   1  s    zBoolBinopNode.coerce_to_booleanc             C   s2   | j j||}| jj||}tj| || j||dS )N)r   r
   rX  rY  )rX  rQ  rY  r}  r  r
   )rP   rh  rg   rX  rY  rN   rN   rO   rQ  1  s    zBoolBinopNode.coerce_toc       
      C   s   |j | j ||f}| jdkr.|jd }	}n|jd }	}| jj|||||||	 |\}}|j|	 | jj||||||| d S )Nr  Znext_andZnext_or)r"  rr   r
   r  rX  generate_bool_evaluation_coder  rY  )
rP   r   final_result_tempfinal_result_type	and_labelor_label	end_labelfall_throughZouter_labelsZmy_labelrN   rN   rO   r  1  s    

z+BoolBinopNode.generate_bool_evaluation_codec             C   sX   | j | | jjrtjn| j}d  }}|jd}| j|| j ||||| |j| d S )NZbool_binop_done)	r  r   re   r   r   r  r  r   r  )rP   r   r  r  r  r  rN   rN   rO   r(  1  s    

z&BoolBinopNode.generate_evaluation_codezTruth-testing Python objectc             C   s   | j j o| jj S )N)rX  r   rY  )rP   rN   rN   rO   r   1  s    zBoolBinopNode.check_constc             C   s   d S )NrN   )rP   r   rN   rN   rO   r&  1  s    z,BoolBinopNode.generate_subexpr_disposal_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r'  1  s    z BoolBinopNode.free_subexpr_tempsc             C   sV   | j jr@|jjtjdd}|jd|| jj |j	|| j
f  n
| jj }|| j jfS )NF)r  z"%s = __Pyx_PyObject_IsTrue(%s); %s)r   re   r  r  r   rx  r   rX  r   r  rr   r   )rP   r   test_resultrN   rN   rO   generate_operand1_test1  s    
z$BoolBinopNode.generate_operand1_test)rR   rS   rT   r  r   r   r
   rX  rY  rv   r  r   r   r   r   r  r  r   rQ  r  r(  r   r   r&  r'  r  rN   rN   rN   rO   r}  :1  s.   
r}  c                   sd   e Zd ZdZddgZdZdZdZ fddZdd	 Z	d
d Z
dd Zdd Zdd Zdd Z  ZS )r  a  
    Intermediate result of a short-circuiting and/or expression.
    Tests the result for 'truthiness' and takes care of coercing the final result
    of the overall expression to the target type.

    Note that this node provides the same code generation method as
    BoolBinopNode to simplify expression nesting.

    arg     ExprNode    the argument to test
    value   ExprNode    the coerced result value node
    re  r   TNc                s<   |j |}t|}tt| j|j||t|j||d d S )N)re  r   r   )r   	ProxyNoderJ   r  r  rr   r  rQ  )rP   re  r  rg   )rM   rN   rO   r  1  s
    

zBoolBinopResultNode.__init__c             C   s   | j tj|S )N)rQ  r   rx  )rP   rg   rN   rN   rO   r   1  s    z%BoolBinopResultNode.coerce_to_booleanc             C   s(   | j j }|tjkr|j|}t|||S )N)re  r   rx  r   r  )rP   rh  rg   re  rN   rN   rO   rQ  1  s    

zBoolBinopResultNode.coerce_toc             C   s   d S )NrN   )rP   rg   rN   rN   rO   r  1  s    zBoolBinopResultNode.nogil_checkc             C   sZ   | j jjrB|jjtjdd}|jd|| j j |j	|| j
f  n
| j j }|| j jjfS )NF)r  z"%s = __Pyx_PyObject_IsTrue(%s); %s)re  r   re   r  r  r   rx  r   r   r  rr   r   )rP   r   r  rN   rN   rO   generate_operand_test1  s    

z)BoolBinopResultNode.generate_operand_testc             C   s  |j | j | jj| |s |r| j|\}}	|	rF|rF|rF| jj| |rNdnd}
|jd|
|f  |	rt|jj| |	 s|o| r| jj| |r||kr|j	| |r|r|jd |	s| jj| ||kr|j	| | s| rd|s|r|jd | j
j| | j
j| |jd|| j
j|f  | j
j| | jj| | j
j| ||krd|j	| |sp|rz|jd | jj| d S )Nr  rD  zif (%s%s) {z} else {z%s = %s;r   )r"  rr   re  r(  r  r+  r   r  r  r  r   r  r   r,  r1  )rP   r   r  r  r  r  r  r  r  Z	uses_tempZsenserN   rN   rO   r  1  sF    






z1BoolBinopResultNode.generate_bool_evaluation_codec             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   /2  s    z!BoolBinopResultNode.analyse_types)rR   rS   rT   r  r   r   re  r   r  r   rQ  r  r  r  r   rU   rN   rN   )rM   rO   r  1  s   	7r  c                   s   e Zd ZdZdZdZdddgZdd Zdd	 Zd
d Z	dd Z
dd Zdd Z fddZ fddZdd Zdd Zdd Zdd Zdd Zd d! Z  ZS )"r^  NTr\  rZ  r[  c             C   s   | j j|| jj| S )N)rZ  r   r[  )rP   rg   rN   rN   rO   r   @2  s    zCondExprNode.type_dependenciesc             C   s   t j| jj|| jj|S )N)r   r~  rZ  rv   r[  )rP   rg   rN   rN   rO   rv   C2  s    
zCondExprNode.infer_typec             C   s"   | j jr| jj| _n
| jj| _d S )N)r\  rp   rZ  r[  )rP   rN   rN   rO   r   H2  s    z&CondExprNode.calculate_constant_resultc             C   s   | j j p| jj S )N)rZ  r   r[  )rP   rN   rN   rO   r   N2  s    zCondExprNode.is_ephemeralc             C   s4   | j j|| _ | jj|| _| jj|| _| j|S )N)r\  r   rZ  r   r[  r`  )rP   rg   rN   rN   rO   r   Q2  s    zCondExprNode.analyse_typesc             C   s   | j j}| jj}tj||| _| jjr6tj| jj| _| jjrFt	| _
n | j j sZ| jj rft| jd |jsz|jsz| jjr|| jkr| j j| j|| _ || jkr| jj| j|| _| jjr| j  | S )NzPUnsafe C derivative of temporary Python reference used in conditional expression)rZ  r   r[  r   r~  r   r  rI  re   r   r   r   r   rr   rQ  rU  r  )rP   rg   Ztrue_val_typeZfalse_val_typerN   rN   rO   r`  W2  s"    

z CondExprNode.analyse_result_typec                sp   | j jjs| j j|| _ | jjjs0| jj|| _d | _| j|}|jjsl|| krbtt|j|}n
|j|}|S )N)	rZ  r   r\  r  r[  r   r`  rJ   r^  )rP   rg   out)rM   rN   rO   r  m2  s    



zCondExprNode.coerce_to_integerc                s~   | j j|kr| j j||| _ | jj|kr8| jj||| _d | _| j|}|j|krz|| krntt|j||}n|j||}|S )N)rZ  r   rQ  r[  r   r`  rJ   r^  )rP   rh  rg   r  )rM   rN   rO   rQ  ~2  s    

zCondExprNode.coerce_toc             C   s<   | j jjp| jjjs0t| jd| j j| jjf  tj| _d S )Nz5Incompatible types in conditional expression (%s; %s))rZ  r   rU  r[  r   rr   r   r,   )rP   rN   rN   rO   r  2  s    zCondExprNode.type_errorc             C   s   | j j o| jj o| jj S )N)r\  r   rZ  r[  )rP   rN   rN   rO   r   2  s    

zCondExprNode.check_constc             C   s   |j | j | j| | jj| |jd| jj   | j|| j |jd | j|| j	 |jd | jj
| | jj| d S )Nz	if (%s) {z} else {r   )r"  rr   r  r\  r(  r   r   eval_and_getrZ  r[  r+  r1  )rP   r   rN   rN   rO   r(  2  s    


z%CondExprNode.generate_evaluation_codec             C   s`   |j | | jjr|j| n
|j| |jd| j |j| j f  |j	| |j
| d S )Nz%s = %s;)r(  r   r   r   r  r   r   r   r   r,  r1  )rP   r   r  rN   rN   rO   r  2  s    

 
zCondExprNode.eval_and_getc             C   s   d S )NrN   )rP   r   rN   rN   rO   r&  2  s    z+CondExprNode.generate_subexpr_disposal_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r'  2  s    zCondExprNode.free_subexpr_temps)rR   rS   rT   rZ  r[  r   r   r   rv   r   r   r   r`  r  rQ  r  r   r(  r  r&  r'  rU   rN   rN   )rM   rO   r^  32  s$   

r^  ZPy_LTZPy_LEZPy_EQZPy_NEZPy_GTZPy_GE)	r%  z<=z==z!=z<>r&  z>=r,  r-  c               @   s   e Zd ZdZdZg 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 Zdd Zd"ddZdd Zdd  ZdS )#CmpNodeNc             C   s   t S )N)r   )rP   rg   rN   rN   rO   rv   2  s    zCmpNode.infer_typec             C   s   t | j }| jj}t|tr:t|tr:t|t|kr:d S | jdkrt| jttt	fr| jj
sn| jdk| _d S t| jtr| j r| jj | _n$t| jtr| jjs| jdk| _d S |||| _d S )Nr,  r-  )r,  r-  )r.  r
   rY  rp   ro   any_string_typer   rN  rn  rJ  r   cascader0  r  r  )rP   Zoperand1_resultr  Zoperand2_resultrN   rN   rO   "calculate_cascaded_constant_result2  s$    



z*CmpNode.calculate_cascaded_constant_resultc             C   sv   t | }| jj|}y|||}W n0 tk
rR } z| j| d }W Y d d }~X nX |rr| j}|rr|op|j||}|S )N)r/  rY  r   r  r   r  cascaded_compile_time_value)rP   rX  r   r  rY  r   r   r  rN   rN   rO   r  2  s    
z#CmpNode.cascaded_compile_time_valuec             C   s   | j jjp| jjjS )N)rX  r   r   rY  )rP   rN   rN   rO   is_cpp_comparison2  s    zCmpNode.is_cpp_comparisonc       	      C   s~   |j }|j }d}d}|jr&|j r&d}|jr8|j r8d}|jrH|rz|S n2|jrX|rz|S n"|rz|rztj||fkrttjS tjS d S )NFT)	r   r  r  r\  r   r   r   r  r  )	rP   rg   r5  rX  rY  r3  r4  Ztype1_can_be_intZtype2_can_be_intrN   rN   rO   find_common_int_type2  s(    zCmpNode.find_common_int_typec       	      C   s  | j }|j}|j}d }|tkr0|jsJ|ttfksJ|tkr\|jsJ|ttfkr\t| jd t}n|j	sh|j	r|dkr|j	s||j
r|j	s|j
rt| jd t}nH|jr|jtjrtjnt}n*|jr|jtjrtjnt}ntj||}n@|j
o|j
r tj||}n$|d ks|j r$| j||||}|d kr |js>|jrDt}n||krT|}n|jsd|jr|j
st|jr|j||rt}nt}nZ|j
s|jr|j||rt}nt}n0tj|rtj|rt}n| j||| t}n6|j|r|}n$|j|r|}n| j||| t}|jrDt|ts@t|trDt}|d ksV|jr\|}ntj||}| jr| jj|| j||}|S )NzFComparisons between bytes/unicode and str are not portable to Python 3==!=zcomplex types are unordered)r  r  )rY  r   r   r$  r   r   r   rr   r,   rb  r  re   r_  r   r  r   r   r  r  r  rH  rc  invalid_types_errorro   r  rU  Zspanning_typer  find_common_typer
   )	rP   rg   r5  rX  common_typerY  r3  r4  Znew_common_typerN   rN   rO   r  3  sp    

zCmpNode.find_common_typec             C   s   t | jd||j|jf  d S )NzInvalid types for '%s' (%s, %s))r   rr   r   )rP   rX  r5  rY  rN   rN   rO   r  j3  s    zCmpNode.invalid_types_errorc             C   s6   | j   o4| j  o4| j p4| jr,| jj p4| jdkS )Nr,  r-  )r,  r-  )is_ptr_containsis_c_string_containshas_python_operandsr  is_python_comparisonr
   )rP   rN   rN   rO   r  n3  s
    

zCmpNode.is_python_comparisonc             C   s6   | j }|j|kr|j||| _ | jr2| jj|| d S )N)rY  r   rQ  r  coerce_operands_to)rP   rh  rg   rY  rN   rN   rO   r  u3  s
    
zCmpNode.coerce_operands_toc             C   s@   | j  r0| jd kr0| jdkr0| j  r0| j  p>| jo>| jj S )NrW  r'  r,  r-  )rW  r'  r,  r-  )r  special_bool_cmp_functionr
   r  r  r  is_python_result)rP   rN   rN   rO   r  |3  s    



zCmpNode.is_python_resultc             C   s@   | j dko>| jjjr*| jjjp>| jjtkp>| jjjo>| jjtkS )Nr,  r-  )r,  r-  )	r
   rX  r   r\  rY  r$  r   r  r   )rP   rN   rN   rO   r  3  s
    


zCmpNode.is_c_string_containsc             C   s*   | j dkr&| jj}|js|jo$|j S d S )Nr,  r-  )r,  r-  )r
   rY  r   rJ  r   r$  )rP   Zcontainer_typerN   rN   rO   r  3  s    
zCmpNode.is_ptr_containsFc       	      C   s  | j dkr2|j| jj }}|s.|jo*|jr|tjksB|tjkrZtjdd| _d| _	dS |tj
ksn|tj
krtjdd| _d| _	dS |tjks|tjkrtjdd| _d| _	dS |tjks|tjkrtjd	d| _d
| _	dS |rddlm} || j dkrdnd| tj|| j}|r|\| _	| _| _}dS n| j dkr| jjtjkrt| jjd| _tjdd| _d| _	dS | jjtjkr| jjd| _tjdd| _d| _	dS | jjtjkr| jjd| _tjdd| _d| _	dS | jjjs| jj|| _tjdd| _d| _	dS dS )N==!=ZUnicodeEqualszStringTools.cZ__Pyx_PyUnicode_EqualsTZBytesEqualsZ__Pyx_PyBytes_EqualsZ	StrEqualsZ__Pyx_PyString_Equalsr%   )optimise_numeric_binopEqZNer,  r-  z!'NoneType' object is not iterableZPyDictContainszObjectHandling.cZ__Pyx_PyDict_ContainsTFZPySetContainsZ__Pyx_PySet_ContainsTFZPyUnicodeContainsZ__Pyx_PyUnicode_ContainsTFZPySequenceContainsZ__Pyx_PySequence_ContainsTFF)r  r  )r,  r-  )r
   r   rY  r
  r   r   r   r   special_bool_cmp_utility_coder  r   r/   r   ZOptimizer  r   rx  special_bool_extra_argsr   r  r   re   rr  )	rP   rg   rX  result_is_boolr3  r4  r  r   r  rN   rN   rO   "find_special_bool_compare_function3  sh    z*CmpNode.find_special_bool_compare_functionc             C   sr  | j jr<|j}d| }| jr6|jjtjdd d}qJd}n|j}d}d}| jr|j jrb|j	 }	n|j
 }	|j jr||j	 }
n|j
 }
djdd	 | jD }| jr|jj| j |jd
||| j|	|
| jr|nt| |||| jf  n|j jo|dkrj|dkst|| j js(| j tjks(t|jd|| j jr>dnd|j	 |j	 t| |||| jf  n|j jr|jd|||dkrdpd|j jd|j
 |j
 f  n|j }|j }|js|jr|j| rt}n|jrtj||}n|}|j|}|j|}d|||| j||f }| j rd| jdkrdt|| j|| j jrT|nd | j | j! n
|j| d S )Nz__Pyx_XGOTREF(%s); ZPyBoolOrNullFromLongzObjectHandling.cZ__Pyx_PyBoolOrNull_FromLongZ__Pyx_PyBool_FromLongrD  z, c             S   s   g | ]}|j  qS rN   )r   )rW   	extra_argrN   rN   rO   r   3  s    z3CmpNode.generate_operation_code.<locals>.<listcomp>z%s = %s(%s(%s, %s, %s)); %s%srW  r'  r,  r-  z-%s = PyObject_RichCompare%s(%s, %s, %s); %s%sZBoolz%s = %s(%s%s(%s, %s));z!=r  eqz%s = %s(%s %s %s);r   )rW  r'  )r,  r-  )"r   re   r   r  r   r   r   r   r  r   r   r  r  r  r   richcmp_constantsrr   r   r   rx  rb  r  r	  rM  r   r  r  r   
c_operatorr  r   r   r   r  )rP   r   r  rX  r5  rY  Zerror_clauseZgot_refZcoerce_resultrD  rE  Zspecial_bool_extra_args_resultr3  r4  r  code1code2Z	statementrN   rN   rO   r  3  s    






zCmpNode.generate_operation_codec             C   s    |dkrdS |dkrdS |S d S )NrW  z==r'  z!=rN   )rP   r5  rN   rN   rO   r  '4  s
    zCmpNode.c_operator)N)F)rR   rS   rT   r  r  r  rv   r  r  r  r  r  r  r  r  r  r  r  r  r  r  rN   rN   rN   rO   r  2  s$   
S
<Zr  c               @   s   e Zd Zd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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 )(r_  rX  rY  coerced_operand2r  r  NFc             C   sN   | j j|}| jj|}t|s(t|rJt|rJt|rJtt| j||S tS )N)	rX  rv   rY  r9   r7   rE   r;   r
   r   )rP   rg   r3  r4  rN   rN   rO   rv   D4  s    zPrimaryCmpNode.infer_typec             C   s   f S )NrN   )rP   rg   rN   rN   rO   r   O4  s    z PrimaryCmpNode.type_dependenciesc             C   s   | j  st| j| jj d S )N)r  r   r  rX  rp   )rP   rN   rN   rO   r   R4  s    z(PrimaryCmpNode.calculate_constant_resultc             C   s   | j j|}| j||S )N)rX  r   r  )rP   r   rX  rN   rN   rO   r   V4  s    z!PrimaryCmpNode.compile_time_valuec             C   s"   | j }x|r| j|_|j }qW d S )N)r  r   )rP   ZcdrrN   rN   rO   unify_cascade_typeZ4  s    z!PrimaryCmpNode.unify_cascade_typec             C   s  | j j|| _ | jj|| _| j rD| j| | jr@t| jd | S | j j}| jj}t	|sdt	|rt
|rt
|rtt| j||| _d| _| S | j|r| S | jr| jj|| _| jdkr| j rnd| _d }| jrt| jd | S | jjtkr|jtjdd nR| j jtjkr.| j jtj|| _ | jjtk	rL| jjt|| _|jtjdd | jjd	| _nj| j r| jrt| jd
 tj| _| S | j|| j r| j jjs| j j|| _ d }d| _n
t }d| _nP| j|| j r| j jjs| j j|| _ d }d| _n| j!|| j| j }|j| _|d k	rh|j" rh| j j|kr\| j j||| _ | j#|| | jr| jj$|| _| jj%| | jj&| j|}|| jk	r|| _'| j( rtj | _ntj| _| j)  | js| js| j*rd| _+| S )Nz5Cascading comparison not yet supported for cpp types.Fr,  r-  z?Cascading comparison not yet supported for 'int_val in string'.ZPyUCS4InUnicodezStringTools.cZBytesContainsz+argument of type 'NoneType' is not iterablez?Cascading comparison not supported for 'val in sliced pointer'.Tr%   )r,  r-  ),rX  r   rY  r  analyse_cpp_comparisonr  r   rr   r   r9   r7   rE   r;   r
   is_pycmp"analyse_memoryviewslice_comparisonr  r   r   r   r   r   r  rQ  r   r   r  r  rx  r  re   rr  r   r  rU  r  r    coerce_cascaded_operands_to_tempoptimise_comparisonr  r  r  r  r   )rP   rg   r3  r4  r  rY  rN   rN   rO   r   `4  s    






zPrimaryCmpNode.analyse_typesc             C   s  | j j}| jj}d| _|j| j| j | jg}|d kr^t| jd| j||f  tj	| _d| _
d S |j}|jrp|j}|j| _|j| _| jdkrd| _t| r|jtjdd t|jdkr| jj|jd	 j|| _n0| j j|jd	 j|| _ | jj|jd j|| _|j| _d S )
NFzInvalid types for '%s' (%s, %s)z<error>r   Tr  zCppSupport.cppr%   r   )rX  r   rY  r  r  r
   r   rr   r   r,   r  rJ  rK  r   r   r   r   r   r   r   r{   r   rQ  r  )rP   rg   r3  r4  r   r  rN   rN   rO   r  4  s0    
z%PrimaryCmpNode.analyse_cpp_comparisonc             C   sV   | j jp| jj}| j jjp"| jjj}d}|rR|rR| j|krRd| _tj| _d| _	dS dS )N==!=rW  r'  FT)r  r  rW  r'  )
rX  rZ  rY  r   r   r
   r  r   rx  is_memslice_nonecheck)rP   rg   Z	have_noneZ
have_sliceopsrN   rN   rO   r  4  s    

z1PrimaryCmpNode.analyse_memoryviewslice_comparisonc             C   sn   | j rb| j|| jddrbd| _ tj| _d| _| jrV| jj| j	|dd}|| j	k	rV|| _
| j  | S tj| |S )NT)r  Fr%   )r  r  rX  r   rx  r   r   r  r  rY  r  r  r   r   )rP   rg   rY  rN   rN   rO   r   4  s    
z PrimaryCmpNode.coerce_to_booleanc             C   s   | j jjp| jjjS )N)rX  r   re   rY  )rP   rN   rN   rO   r  4  s    
z"PrimaryCmpNode.has_python_operandsc             C   s*   | j r| j  dS | jj o$| jj S d S )NF)r  r  rX  r   rY  )rP   rN   rN   rO   r   4  s    zPrimaryCmpNode.check_constc             C   s   | j | j }}|jjrJ| jdkr&d}nd}d||jjd|j |j f S | j r|jtkrbd}nd}| jdkrvd}nd}d|||j |j f S t	| jr|j
 |j
  }}n2|j |j  }}| jr|jjrd	| }nd	| }d
|| j| j|f S d S )Nz!=r  rD  z(%s%s(%s, %s))z==Z__Pyx_UnicodeContainsUCS4Z__Pyx_BytesContainsr-  z((PyObject *) %s.memview)z
(%s %s %s))rX  rY  r   rb  r
   rC  r   r  r   r9   r   r  r   r  )rP   rX  rY  ZnegationmethodrD  rE  rN   rN   rO   r   4  sB    






z$PrimaryCmpNode.calculate_result_codec             C   s   | j j| | jj| x| jD ]}|j| q W | jr| j| | j|| j | j | j| j | j	r| j	j|| j | j
p|| j| j
d k	d | j j| | j j| | jj| | jj| d S )N)needs_evaluation)rX  r(  rY  r  r   r  r  r   r
   r  r  r+  r1  )rP   r   r  rN   rN   rO   r(  #5  s     
z'PrimaryCmpNode.generate_evaluation_codec             C   s   | j j| | jj| d S )N)rX  r+  rY  )rP   r   rN   rN   rO   r&  55  s    z-PrimaryCmpNode.generate_subexpr_disposal_codec             C   s   | j j| | jj| d S )N)rX  r1  rY  )rP   r   rN   rN   rO   r'  ;5  s    z!PrimaryCmpNode.free_subexpr_tempsc             C   s.   | j j| | jj| | jr*| jj| d S )N)rX  rC  rY  r  )rP   r   rN   rN   rO   rC  A5  s    zPrimaryCmpNode.annotate)rR   rS   rT   r   r  r  r  rv   r   r   r   r  r   r  r  r   r  r   r   r(  r&  r'  rC  rN   rN   rN   rO   r_  /4  s*   T*r_  c               @   s   e Zd ZddddgZdZdZe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 Zdd ZdddZdd ZdS )CascadedCmpNoderY  r  r  r  Nc             C   s   t S )N)r   )rP   rg   rN   rN   rO   rv   Y5  s    zCascadedCmpNode.infer_typec             C   s   f S )NrN   )rP   rg   rN   rN   rO   r   ]5  s    z!CascadedCmpNode.type_dependenciesc             C   s   | j tk	o| j tk	S )N)rp   r   r   )rP   rN   rN   rO   r~   `5  s    
z#CascadedCmpNode.has_constant_resultc             C   s&   | j j|| _ | jr"| jj|| _| S )N)rY  r   r  )rP   rg   rN   rN   rO   r   d5  s    zCascadedCmpNode.analyse_typesc             C   s
   | j jjS )N)rY  r   re   )rP   rN   rN   rO   r  j5  s    z#CascadedCmpNode.has_python_operandsc             C   s   dS )NFrN   )rP   rN   rN   rO   r  m5  s    z!CascadedCmpNode.is_cpp_comparisonFc             C   sZ   | j |||r.d| _tj| _|jjs.|j|}| jrV| jj| j	||}|| j	k	rV|| _
|S )NF)r  r  r   rx  r   re   rr  r  r  rY  r  )rP   rX  rg   r  rY  rN   rN   rO   r  q5  s    

z#CascadedCmpNode.optimise_comparisonc             C   sH   | j j|| _ | j jtkr2| jdkr2| j jd| _ | jrD| jj| d S )Nr,  r-  z!'NoneType' object is not iterable)r,  r-  )rY  rr  r   r   r
   r  r  r1  )rP   rg   rN   rN   rO   r1  }5  s
    z,CascadedCmpNode.coerce_operands_to_pyobjectsc             C   s$   | j r | jj|| _| j j| d S )N)r  rY  r   r  )rP   rg   rN   rN   rO   r  5  s    z0CascadedCmpNode.coerce_cascaded_operands_to_tempc             C   s   | j jr&|jd|  |j|| j  n|jd|  |rB|j| | jj| x| jD ]}|j| qVW | j|||| j| j | j	r| j	j||| j
p| j| j
d k	d |r|j| |j| | jj| | jj| |jd d S )Nz if (__Pyx_PyObject_IsTrue(%s)) {z	if (%s) {)r  r   )r   re   r   r  r(  rY  r  r  r
   r  r  r+  r1  )rP   r   r   rX  r  r  rN   rN   rO   r(  5  s*    


z(CascadedCmpNode.generate_evaluation_codec             C   s"   | j j| | jr| jj| d S )N)rY  rC  r  )rP   r   rN   rN   rO   rC  5  s    zCascadedCmpNode.annotate)F)F)rR   rS   rT   r   r  r  r   rp   rv   r   r~   r   r  r  r  r1  r  r(  rC  rN   rN   rN   rO   r  H5  s    


r  )r  r  r  r*  r  z<<z>>r   r  r   r+  r(  z//r)  z**c             K   s   t | | f||||d|S )N)r
   rX  rY  r  )binop_node_classes)rr   r
   rX  rY  r  r  rN   rN   rO   r  5  s    r  c                   s>   e Zd ZdgZeZ fddZdd Zdd Zdd	 Z	  Z
S )
r  re  c                s2   t t| j|j || _tr.td| | jf  d S )Nz%s Coercing %s)rJ   r  r  rr   re  r   rS  )rP   re  )rM   rN   rO   r  5  s    zCoercionNode.__init__c             C   s   d S )NrN   )rP   rN   rN   rO   r   5  s    z&CoercionNode.calculate_constant_resultc             C   sX   | j j| | j j| jkrT| j\}}}|j|||d ftddd| j j| jf d d S )Nr%   Zcoercez[%s] to [%s])rb  tagrc  )re  rC  r   rr   r3   )rP   r   filelinecolrN   rN   rO   rC  5  s
    zCoercionNode.annotatec             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   5  s    zCoercionNode.analyse_types)rR   rS   rT   r   r   rp   r  r   rC  r   rU   rN   rN   )rM   rO   r  5  s   r  c               @   s    e Zd ZdZdd Zdd ZdS )rR  zc
    Coerce an object to a memoryview slice. This holds a new reference in
    a managed temp.
    c             C   sL   |j s
t|jj  sttj| | || _d| _d| _|| _| jj| d S )Nr%   T)	r   r   r   r  r  r   r  re  r  )rP   re  rh  rg   rN   rN   rO   r  5  s    
z!CoerceToMemViewSliceNode.__init__c             C   s(   |j | jj| jj | j | j| d S )N)r   r   from_py_call_codere  r   r   rr   )rP   r   rN   rN   rO   r#   6  s
    
z-CoerceToMemViewSliceNode.generate_result_codeN)rR   rS   rT   r  r  r#  rN   rN   rN   rO   rR  5  s   
rR  c               @   s,   e Zd Zdd Zdd Zdd Zdd Zd	S )
r  c             C   s   t j| | || _d S )N)r  r  r   )rP   re  new_typerN   rN   rO   r  6  s    zCastNode.__init__c             C   s
   | j j S )N)re  r  )rP   rN   rN   rO   r  6  s    zCastNode.may_be_nonec             C   s   | j j| jS )N)re  r   r   )rP   rN   rN   rO   r   6  s    zCastNode.calculate_result_codec             C   s   | j j| d S )N)re  r#  )rP   r   rN   rN   rO   r#  6  s    zCastNode.generate_result_codeN)rR   rS   rT   r  r  r   r#  rN   rN   rN   rO   r  	6  s   r  c               @   s   e Zd ZdZd%ddZej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$S )&r`  TFc             C   sD   |j s|jstd|j|f tj| | || _|j | _|| _d S )Nz/PyTypeTest for %s against non extension type %s)	r	  r
  r   r   r  r  r   r   r  )rP   re  rh  rg   r  rN   rN   rO   r  !6  s    
zPyTypeTestNode.__init__zPython type testc             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   .6  s    zPyTypeTestNode.analyse_typesc             C   s   | j r
dS | jj S )NF)r  re  r  )rP   rN   rN   rO   r  16  s    zPyTypeTestNode.may_be_nonec             C   s
   | j j S )N)re  r  )rP   rN   rN   rO   r  66  s    zPyTypeTestNode.is_simplec             C   s
   | j j S )N)re  r
  )rP   rN   rN   rO   r
  96  s    zPyTypeTestNode.result_in_tempc             C   s
   | j j S )N)re  r   )rP   rN   rN   rO   r   <6  s    zPyTypeTestNode.is_ephemeralc             C   s
   | j j S )N)re  r   )rP   rN   rN   rO   r   ?6  s    z#PyTypeTestNode.nonlocally_immutablec             C   sT   | j | jj ks| jj r| S | j j s*| S | jj rN| jrN| jjd| j j S | jS )Nz!Cannot convert NoneType to %.200s)r   re  r   typeobj_is_availabler  r  r  rf   )rP   rN   rN   rO   	reanalyseB6  s    
zPyTypeTestNode.reanalysec             C   s   d S )NrN   )rP   rN   rN   rO   r   K6  s    z(PyTypeTestNode.calculate_constant_resultc             C   s
   | j j S )N)re  r   )rP   rN   rN   rO   r   O6  s    z$PyTypeTestNode.calculate_result_codec             C   s   | j j r| j jrD| j j| jj | j| jd}|jj	t
jdd n*| j j| jj | j}|jj	t
jdd |jd||j| jf  nt| jd d S )N)exactZRaiseUnexpectedTypeErrorzObjectHandling.cZExtTypeTestzif (!(%s)) %szICannot test type of extern C class without type object name specification)r   r  r
  Ztype_test_codere  r   r  r  r   r   r   r   r   r   rr   r   )rP   r   Z	type_testrN   rN   rO   r#  R6  s    

z#PyTypeTestNode.generate_result_codec             C   s   | j j| d S )N)re  r,  )rP   r   rN   rN   rO   r,  e6  s    z,PyTypeTestNode.generate_post_assignment_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r  h6  s    z#PyTypeTestNode.allocate_temp_resultc             C   s   d S )NrN   )rP   r   rN   rN   rO   r  k6  s    z"PyTypeTestNode.release_temp_resultc             C   s   | j j| d S )N)re  r1  )rP   r   rN   rN   rO   r1  n6  s    zPyTypeTestNode.free_tempsc             C   s   | j j| d S )N)re  r'  )rP   r   rN   rN   rO   r'  q6  s    z!PyTypeTestNode.free_subexpr_tempsN)F)rR   rS   rT   r  r  r(   r  r  r   r   r  r  r
  r   r   r  r   r   r#  r,  r  r  r1  r'  rN   rN   rN   rO   r`  6  s&   

	r`  c               @   s   e Zd ZdZf f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edf dfddZedf dfddZdd Zdd Zdd Zdd  ZdS )!r  Tc             C   s<   t j| | |j| _|j | _|| _|| _t|p2f | _d S )N)	r  r  r   r   r   exception_type_cnameexception_messager   exception_format_args)rP   re  r  r  r  rN   rN   rO   r  |6  s    
zNoneCheckNode.__init__Nc             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   6  s    zNoneCheckNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r  6  s    zNoneCheckNode.may_be_nonec             C   s
   | j j S )N)re  r  )rP   rN   rN   rO   r  6  s    zNoneCheckNode.is_simplec             C   s
   | j j S )N)re  r
  )rP   rN   rN   rO   r
  6  s    zNoneCheckNode.result_in_tempc             C   s
   | j j S )N)re  r   )rP   rN   rN   rO   r   6  s    z"NoneCheckNode.nonlocally_immutablec             C   s
   | j j S )N)re  r   )rP   rN   rN   rO   r   6  s    z#NoneCheckNode.calculate_result_codec             C   s4   | j jr| jj S | j jr(d| jj  S tdd S )Nz((PyObject *) %s.memview)zunsupported type)r   re   re  r   r   r   r  )rP   rN   rN   rO   	condition6  s
    
zNoneCheckNode.conditionr  Fc             C   s"   | ||||}||_ |j| d S )N)r  put_nonecheck)rL   re  r   r  r  r  r  rt   rN   rN   rO   generate6  s    zNoneCheckNode.generatec             C   s    |j  r| j|||||| d S )N)r  r  )rL   re  r   r  r  r  r  rN   rN   rO   generate_if_needed6  s    z NoneCheckNode.generate_if_neededc                s   |j d| j   | jr |j  tj | jrh|j d| jtj| jj	ddj
 fdd| jD f  n |j d| j | jj	df  | jr|j  |j |j| j |j d d S )	Nzif (unlikely(%s == Py_None)) {zPyErr_Format(%s, "%s", %s);zUTF-8z, c                s"   g | ]}d  t |jd qS )z"%s"zUTF-8)rk   r  )rW   re  )escaperN   rO   r   6  s   z/NoneCheckNode.put_nonecheck.<locals>.<listcomp>zPyErr_SetString(%s, "%s");r   )r   r  r  r   r	   Zescape_byte_stringr  r  r  r  r  r   r   rr   )rP   r   rN   )r  rO   r  6  s&    zNoneCheckNode.put_nonecheckc             C   s   | j | d S )N)r  )rP   r   rN   rN   rO   r#  6  s    z"NoneCheckNode.generate_result_codec             C   s   | j j| d S )N)re  r,  )rP   r   rN   rN   rO   r,  6  s    z+NoneCheckNode.generate_post_assignment_codec             C   s   | j j| d S )N)re  r1  )rP   r   rN   rN   rO   r1  6  s    zNoneCheckNode.free_temps)rR   rS   rT   r+  r  r  r   r  r  r
  r   r   r  r  r  r  r  r#  r,  r1  rN   rN   rN   rO   r  u6  s$   r  c               @   sP   e Zd ZeZeZdZefddZdZdd Z	dd Z
d	d
 Zdd Zdd ZdS )r^  r%   c             C   s   |j j|s t|jd|j   n|j jr2|j|}tj| | |tkr|j j	sV|j j
rbt|| _ n(|j jsr|j jrzt| _ n|j jrtj| _ | j | _nR|j j	s|j j
r|ttfkr|jd  rt|jd|j |f  | | _ | _n|| _d S )Nz$Cannot convert '%s' to Python objectrV   z:default encoding required for conversion from '%s' to '%s')r   r  r   rr   rb  r   r  r  r   r$  rd  rm   r%  r  r   r   r  target_typer   r   r_   )rP   re  rg   r   rN   rN   rO   r  6  s*    

zCoerceToPyTypeNode.__init__zConverting to Python objectc             C   s   dS )NFrN   )rP   rN   rN   rO   r  6  s    zCoerceToPyTypeNode.may_be_nonec             C   s<   | j j}|tjks"|jr.|jdkr.| j j|S t| |S d S )Nr   )re  r   r   rx  re   rf   r  rz  )rP   rg   r  rN   rN   rO   r   6  s
    
z$CoerceToPyTypeNode.coerce_to_booleanc             C   s$   | j jjr| j S | j jtj|S d S )N)re  r   r\  rQ  r   r  )rP   rg   rN   rN   rO   r  7  s    
z$CoerceToPyTypeNode.coerce_to_integerc             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   7  s    z CoerceToPyTypeNode.analyse_typesc             C   sH   |j d| jjj| jj | j | j|j| j | jf  | j| d S )Nz%s; %s)	r   re  r   Zto_py_call_coder   r  r   rr   r=  )rP   r   rN   rN   rO   r#  7  s    z'CoerceToPyTypeNode.generate_result_codeN)rR   rS   rT   r   r   r  r   r  r   r  r   r  r   r#  rN   rN   rN   rO   r^  6  s   r^  c               @   s    e Zd ZdZdd Zdd ZdS )r]  r%   c             C   s"   |j |}tj| | tj| _d S )N)r   r  r  r   r   r   )rP   re  rg   rN   rN   rO   r  !7  s    
zCoerceIntToBytesNode.__init__c             C   s   | j }|j }|jtjtjtjfkrn|jjr@|jd||f  n|jd|  |jd|j	| j
  |jd d }|jtjk	r|jjtjdd}|jd||f  |}|jd| j ||j| j | j
f  |d k	r|jj| | j| d S )	Nzif ((%s < 0) || (%s > 255)) {zif (%s > 255) {zOPyErr_SetString(PyExc_OverflowError, "value too large to pack into a byte"); %sr   F)r  z%s = (char)%s;z*%s = PyBytes_FromStringAndSize(&%s, 1); %s)re  r   r   r   r   r  r#  r   r   r   rr   r  r  r   r  r=  )rP   r   re  Z
arg_resultr8  rN   rN   rO   r#  &7  s0    

z)CoerceIntToBytesNode.generate_result_codeN)rR   rS   rT   r   r  r#  rN   rN   rN   rO   r]  7  s   r]  c               @   s8   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d ZdS )ra  Nc             C   s   t j| | || _d| _|j|s2t|jd|  | jjsB| jjr| j	j
rp| j	jrp| j	jjrpt|jd| dd | jjrt|jddd d S )Nr%   z$Cannot convert Python object to '%s'z=Obtaining '%s' from externally modifiable global Python value)rn   a  Py_UNICODE* has been removed in Python 3.12. This conversion to a Py_UNICODE* will no longer compile in the latest Python versions. Use Python C API functions like PyUnicode_AsWideCharString if you need to obtain a wchar_t* on Windows (and free the string manually after use).)r  r  r   r   r  r   rr   r$  r%  re  r   r   r2  r   )rP   r  re  rg   rN   rN   rO   r  J7  s    

zCoerceFromPyTypeNode.__init__c             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   ^7  s    z"CoerceFromPyTypeNode.analyse_typesc             C   s   | j jo| j j o| jj S )N)r   rJ  r   re  r   )rP   rN   rN   rO   r   b7  s    z!CoerceFromPyTypeNode.is_ephemeralc          	   C   s   d }| j jrN| jj tkrN| j jjdrNd| j jtdd   }tj| j|d |j	| j j
| jj | j | j||| jd | j jr| j| d S )NZ__Pyx_PyObject_AsZ__Pyx_PyBytesZ__Pyx_PyObjectzexpected bytes, NoneType found)from_py_functionspecial_none_cvalue)r   r$  re  r   r  r  r{   r  r  r   r  r   r   rr   r  re   r=  )rP   r   r  rN   rN   rO   r#  e7  s    
z)CoerceFromPyTypeNode.generate_result_codec             C   s   t | jd d S )Nz0Coercion from Python not allowed without the GIL)r   rr   )rP   rg   rN   rN   rO   r  u7  s    z CoerceFromPyTypeNode.nogil_check)	rR   rS   rT   r  r  r   r   r#  r  rN   rN   rN   rO   ra  C7  s   ra  c               @   st   e Zd ZejZejdejdej	dej
dejdejdejdiZdd Zd	d
 ZdZdd Zdd Zdd Zdd ZdS )rz  ZPyList_GET_SIZEZPyTuple_GET_SIZEZPySet_GET_SIZEZPyBytes_GET_SIZEZPyByteArray_GET_SIZEZ__Pyx_PyUnicode_IS_TRUEc             C   s   t j| | |jjrd| _d S )Nr%   )r  r  r   re   r   )rP   re  rg   rN   rN   rO   r  7  s    zCoerceToBooleanNode.__init__c             C   s*   | j jjr&| jj| j jd kr&| j  d S )N)re  r   re   _special_builtinsr^   r  )rP   rg   rN   rN   rO   r  7  s    zCoerceToBooleanNode.nogil_checkzTruth-testing Python objectc             C   s   | j r| j  dS | jj S )NF)r   r  re  r   )rP   rN   rN   rO   r   7  s    zCoerceToBooleanNode.check_constc             C   s   d| j j  S )Nz	(%s != 0))re  r   )rP   rN   rN   rO   r   7  s    z)CoerceToBooleanNode.calculate_result_codec             C   s   | j s
d S | jj| jj}|d k	rv| jj r<d| jj  gng }|jd|| jj f  |jd| j	 dj
|f  n,|jd| j	 | jj |j| j	 | jf  d S )Nz(%s != Py_None)z(%s(%s) != 0)z%s = %s;z&&z"%s = __Pyx_PyObject_IsTrue(%s); %s)r   r  r^   re  r   r  r   r   r   r   r  r  rr   )rP   r   Z	test_funcZchecksrN   rN   rO   r#  7  s    z(CoerceToBooleanNode.generate_result_codec             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   7  s    z!CoerceToBooleanNode.analyse_typesN)rR   rS   rT   r   rx  r   r   r   r   r   Zfrozenset_typer   r   r   r  r  r  r   r   r   r#  r   rN   rN   rN   rO   rz  y7  s   
rz  c               @   s,   e Zd Zdd Zdd Zdd Zdd Zd	S )
rd  c             C   s2   |j jr|j|}|| _ tj| | |j| d S )N)r   rb  r   r  r  r  )rP   re  rh  rg   rN   rN   rO   r  7  s
    
zCoerceToComplexNode.__init__c             C   sT   | j jjr4| j jj| j j }| j jj| j j }n| j j }d}d| jj||f S )Nr  z
%s(%s, %s))re  r   rb  r  r   r  r  )rP   r   r  rN   rN   rO   r   7  s    

z)CoerceToComplexNode.calculate_result_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r#  7  s    z(CoerceToComplexNode.generate_result_codec             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   7  s    z!CoerceToComplexNode.analyse_typesN)rR   rS   rT   r  r   r#  r   rN   rN   rN   rO   rd  7  s   rd  c             C   s   ddl m} tjtjtjdtjd tjdtjd gdddd}t| j	d|t
jd	d
| || j	gd}|j|}|j|kr|j||}|S )Nr%   )
HasGilNoder   r  z-1T)r   r   r   Z__Pyx_SoftComplexToDoubleZSoftComplexToDoublez	Complex.c)rC  r   )r]  r  r   r  r  r  re  rx  r  rr   r   r   r   r   rQ  )re  rh  rg   r  Z
cfunc_typerl  rN   rN   rO   rf  7  s$    


rf  c               @   s8   e Zd Zdd ZdZdd Zdd Zdd	 Zd
d ZdS )r  c             C   s<   t j| | | jjj | _| jj| _d| _| jjr8t| _	d S )Nr%   )
r  r  re  r   Zas_argument_typerp   r   re   r   r   )rP   re  rg   rN   rN   rO   r  7  s    
zCoerceToTempNode.__init__z#Creating temporary Python referencec             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   7  s    zCoerceToTempNode.analyse_typesc             C   s
   | j j S )N)re  r  )rP   rN   rN   rO   r  7  s    zCoerceToTempNode.may_be_nonec             C   s4   | j j|| _ | j j r| j S | j j| _| j| _| S )N)re  r   r  r   r   )rP   rg   rN   rN   rO   r   7  s    

z"CoerceToTempNode.coerce_to_booleanc             C   sd   |j d| j | jj| j f  | jr`| jjsF|j| j | j  n|j	| j | j| j
 d d S )Nz%s = %s;)r  )r   r   re  r   r   r  r   r   r  r  r  )rP   r   rN   rN   rO   r#  8  s    z%CoerceToTempNode.generate_result_codeN)	rR   rS   rT   r  r   r   r  r   r#  rN   rN   rN   rO   r  7  s   r  c                   st   e Zd ZdZdZ f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  ZS )r  z
    A node that should not be replaced by transforms or other means,
    and hence can be useful to wrap the argument to a clone node

    MyNode    -> ProxyNode -> ArgNode
    CloneNode -^
    Nc                s$   t t| j| |j| _| j  d S )N)rJ   r  r  rp   update_type_and_entry)rP   re  )rM   rN   rO   r  8  s    zProxyNode.__init__c             C   s   | j j|| _ | j  | S )N)re  r   r  )rP   rg   rN   rN   rO   r   8  s    zProxyNode.analyse_typesc             C   s   | j j|S )N)re  rv   )rP   rg   rN   rN   rO   rv   #8  s    zProxyNode.infer_typec             C   s>   t | jdd }|r"|| _| jj| _t | jdd }|r:|| _d S )Nr   r   )r   re  r   r   r   )rP   r   	arg_entryrN   rN   rO   r  &8  s    
zProxyNode.update_type_and_entryc             C   s   | j j| d S )N)re  r#  )rP   r   rN   rN   rO   r#  /8  s    zProxyNode.generate_result_codec             C   s
   | j j S )N)re  r   )rP   rN   rN   rO   r   28  s    zProxyNode.resultc             C   s
   | j j S )N)re  r  )rP   rN   rN   rO   r  58  s    zProxyNode.is_simplec             C   s
   | j j S )N)re  r  )rP   rN   rN   rO   r  88  s    zProxyNode.may_be_nonec             C   s   | j j| d S )N)re  r(  )rP   r   rN   rN   rO   r(  ;8  s    z"ProxyNode.generate_evaluation_codec             C   s   | j j| d S )N)re  r+  )rP   r   rN   rN   rO   r+  >8  s    z ProxyNode.generate_disposal_codec             C   s   | j j| d S )N)re  r1  )rP   r   rN   rN   rO   r1  A8  s    zProxyNode.free_temps)rR   rS   rT   r  r  r  r   rv   r  r#  r   r  r  r(  r+  r1  rU   rN   rN   )rM   rO   r  8  s   	r  c                   s   e Zd Zg ZdZdd Zdd Zdd Zdd	 Zd
d Z	dd Z
 fddZdd Zdd Zdd Zdd Zdd Zdd Z  ZS )r  Nc             C   sL   t j| | |j| _t|dd }|r2|| _|j| _t|dd }|rH|| _d S )Nr   r   )r  r  rp   r   r   r   r   )rP   re  r   r  rN   rN   rO   r  O8  s    zCloneNode.__init__c             C   s
   | j j S )N)re  r   )rP   rN   rN   rO   r   Z8  s    zCloneNode.resultc             C   s
   | j j S )N)re  r  )rP   rN   rN   rO   r  ]8  s    zCloneNode.may_be_nonec             C   s   | j j|S )N)re  r   )rP   rg   rN   rN   rO   r   `8  s    zCloneNode.type_dependenciesc             C   s   | j j|S )N)re  rv   )rP   rg   rN   rN   rO   rv   c8  s    zCloneNode.infer_typec             C   s6   | j j| _| j j| _d| _t| j dd }|r2|| _| S )Nr%   r   )re  r   r   r   r   r   )rP   rg   r  rN   rN   rO   r   f8  s    

zCloneNode.analyse_typesc                s(   | j jr| j j||S tt| j||S )N)re  r   rQ  rJ   r  )rP   Z	dest_typerg   )rM   rN   rO   rQ  o8  s    zCloneNode.coerce_toc             C   s   dS )NTrN   )rP   rN   rN   rO   r  t8  s    zCloneNode.is_simplec             C   s   d S )NrN   )rP   r   rN   rN   rO   r(  w8  s    z"CloneNode.generate_evaluation_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r#  z8  s    zCloneNode.generate_result_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r+  }8  s    z CloneNode.generate_disposal_codec             C   s   | j r|j| j | j  d S )N)r   r  r   r   )rP   r   rN   rN   rO   r,  8  s    z'CloneNode.generate_post_assignment_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r1  8  s    zCloneNode.free_temps)rR   rS   rT   r   r  r  r   r  r   rv   r   rQ  r  r(  r#  r+  r,  r1  rU   rN   rN   )rM   rO   r  D8  s   	r  c                   sB   e Zd ZdZdZedd Zdd Zdd Zd fd	d
	Z	  Z
S )CppOptionalTempCoercionz
    Used only in CoerceCppTemps - handles cases the temp is actually a OptionalCppClassType (and thus needs dereferencing when on the rhs)
    Fc             C   s   | j jS )N)re  r   )rP   rN   rN   rO   r   8  s    zCppOptionalTempCoercion.typec             C   s   d| j j  S )Nz(*%s))re  r   )rP   rN   rN   rO   r   8  s    z-CppOptionalTempCoercion.calculate_result_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r#  8  s    z,CppOptionalTempCoercion.generate_result_codec                s   t t| j|ddS )NF)r   )rJ   r  r   )rP   r   r   )rM   rN   rO   r   8  s    z-CppOptionalTempCoercion._make_move_result_rhs)F)rR   rS   rT   r  r   r  r   r   r#  r   rU   rN   rN   )rM   rO   r  8  s   r  c               @   s   e Zd Zdd ZdS )r  c             C   s$   |j r| jj|r| S tj| ||S )N)r
  r   r_  r  rQ  )rP   rh  rg   rN   rN   rO   rQ  8  s    zCMethodSelfCloneNode.coerce_toN)rR   rS   rT   rQ  rN   rN   rN   rO   r  8  s   r  c               @   s8   e Zd ZeZdZg Zdd Zdd Zdd Z	dd	 Z
d
S )ModuleRefNodeFc             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   8  s    zModuleRefNode.analyse_typesc             C   s   dS )NFrN   )rP   rN   rN   rO   r  8  s    zModuleRefNode.may_be_nonec             C   s   t jS )N)r   rZ  )rP   rN   rN   rO   r   8  s    z#ModuleRefNode.calculate_result_codec             C   s   d S )NrN   )rP   r   rN   rN   rO   r#  8  s    z"ModuleRefNode.generate_result_codeN)rR   rS   rT   r   r   r   r   r   r  r   r#  rN   rN   rN   rO   r  8  s   r  c               @   s2   e Zd ZdgZeZdZdd Zdd Zdd Z	d	S )
DocstringRefNoderc  Tc             C   s"   t j| | |jjst|| _d S )N)r   r  r   re   r   rc  )rP   rr   rc  rN   rN   rO   r  8  s    zDocstringRefNode.__init__c             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   8  s    zDocstringRefNode.analyse_typesc             C   sH   |j d| j | jj |jtjd|j| j | jf  | j| d S )Nz%s = __Pyx_GetAttr(%s, %s); %sr  )	r   r   rc  rE  r	   r  r   rr   r=  )rP   r   rN   rN   rO   r#  8  s
    z%DocstringRefNode.generate_result_codeN)
rR   rS   rT   r   r   r   r   r  r   r#  rN   rN   rN   rO   r  8  s   r  c               @   s@   e Zd Zg ZdZdddZdd Zdd Zd	d
 ZdddZ	dS )AnnotationNodeFNc             C   sX   t j| | |dkrHddlm} tj|ddj|}t|||j d}|| _	|| _
dS )z5string is expected to already be a StringNode or NoneNr%   )r_  r  )description)r   r   )r   r  rb  r_  r	   r  writer  Zas_utf8_stringr`  r  )rP   rr   r  r`  r_  rN   rN   rO   r  8  s    zAnnotationNode.__init__c             C   s   | S )NrN   )rP   rg   rN   rN   rO   r   8  s    zAnnotationNode.analyse_typesc             C   s   | j |d S )Nr%   )r  )rP   rg   rN   rN   rO   r   8  s    zAnnotationNode.analyse_as_typec             C   s   t |tr|j}|jr<|j|jst|jd| jj	 dd n|j
r|jjr|j|jjsrt|jd| jj	 dd q|jjr|jj|}|r|j|j rt|jd| jj	  q|jj|}|r|jrt|jd| jj	 dd nt|jd dS )zZMethod checks for cases when user should be warned that annotation contains unknown types.z5Unknown type declaration '%s' in annotation, ignoringr%   )rn   z+Unknown type declaration '%s' in annotationz0Unknown type declaration in annotation, ignoringN)ro   rS  r   r   r|  rf   r   rr   r`  r   r  rs  r8  r   r  rt  r   Zpxd_file_loaded)rP   rg   r  r  rN   rN   rO   _warn_on_unknown_annotation8  s(    

z*AnnotationNode._warn_on_unknown_annotationc       
      C   sf  | j rg d fS | j}d }}|jrt|jddd xD|jD ]:\}}|jsJq:|jdkrbd}|st|}q:|jdkr:d}|}q:W |r|rt|jd
dd n"t|t	rt|jddd g d fS |j
|d |j|}|d kr| j|| g |fS |jr t|jddd |r,| r,|jp|j r,t|jd |jr>|j| |jrP|j|ng }	W d Q R X |	|fS )NFzSDicts should no longer be used as type annotations. Use 'cython.int' etc. directly.r%   )rn   r      typeTr      ctypez9Duplicate type declarations found in signature annotationzTTuples cannot be declared as simple tuples of types. Use 'tuple[type1, type2, ...]'.)r  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   r  )r   r  )untypedr  r  r   rr   r  r  r   ro   rn  Znew_c_type_contextr   r  re   r%  rb  r  r  r  )
rP   rg   Zassigned_valuer  Zexplicit_pytypeZexplicit_ctyperf   r   r  r  rN   rN   rO   r  9  sN    





 
 z&AnnotationNode.analyse_type_annotation)N)N)
rR   rS   rT   r   r  r  r   r   r  r  rN   rN   rN   rO   r  8  s   

r  c                   s   e Zd ZdZdgZddgZdZdZdZ fddZ	e
dd	 Ze
d
d Zdd Zdd Zdd Z fddZdd Zdd Z  ZS )AssignmentExpressionNodez
    Also known as a named expression or the walrus operator

    Arguments
    lhs - NameNode - not stored directly as an attribute of the node
    rhs - ExprNode

    Attributes
    rhs        - ExprNode
    assignment - SingleAssignmentNode
    r|   r;  FNc                s>   t t| j|f| t|| _t| j}t|||dd| _d S )NT)rB  r|   r&  )rJ   r  r  r  r|   r  r*   r;  )rP   rr   rB  r|   r  Zassign_expr_rhs)rM   rN   rO   r  \9  s
    

z!AssignmentExpressionNode.__init__c             C   s   | j jS )N)r|   r   )rP   rN   rN   rO   r   c9  s    zAssignmentExpressionNode.typec             C   s
   | j jjS )N)r;  rB  rf   )rP   rN   rN   rO   target_nameg9  s    z$AssignmentExpressionNode.target_namec             C   s   | j j|S )N)r|   rv   )rP   rg   rN   rN   rO   rv   k9  s    z#AssignmentExpressionNode.infer_typec             C   s   | j j| d S )N)r;  rw  )rP   rg   rN   rN   rO   rw  n9  s    z-AssignmentExpressionNode.analyse_declarationsc             C   sX   | j j|| _ | j jjsF| j jjs6| j jj|| j _ntj| j | j_ | jj|| _| S )N)r|   r   re  r   r   r  re  r;  )rP   rg   rN   rN   rO   r   q9  s    


z&AssignmentExpressionNode.analyse_typesc                s   || j jjkr| jj}t|tr&|j}|j||}||k	r|| j_| jj  t| j jtrt| j jt	 r| j jj| j _| j jjj| j j_| S t
t| j||S )N)r;  r|   r   re  ro   r  rQ  r  r  r  rJ   r  )rP   rh  rg   Zold_rhs_argZrhs_arg)rM   rN   rO   rQ  9  s    

z"AssignmentExpressionNode.coerce_toc             C   s
   | j j S )N)r|   r   )rP   rN   rN   rO   r   9  s    z.AssignmentExpressionNode.calculate_result_codec             C   s   | j j| d S )N)r;  r8  )rP   r   rN   rN   rO   r#  9  s    z-AssignmentExpressionNode.generate_result_code)rR   rS   rT   r  r   r   r   r;  Z
clone_noder  r  r   r  rv   rw  r   rQ  r   r#  rU   rN   rN   )rM   rO   r  H9  s   r  )NN)F(6  
__future__r   ZcythonZdeclarer$  Zbintrer  re  os.pathr  r
   ZErrorsr   r   r   r   r   r   r&   r'   ZCoder   r   rD  r	   r   r   r(   r)   r*   r   r   r+   r,   r-   r.   r   r   r   r   r   r   r   r   r   r   r/   r    r0   r1   r"   r!   r   r   ZAnnotater3   r4   Z	Debuggingr5   Z
DebugFlagsr   r   ZPythranr6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   __builtin__rF   ImportErrorrk   ri   r  rl   version_infor$   r  r#   longrH   r   r   ra   rc   rb   rd   rl  Zc_const_py_unicode_ptr_typer]   r   rm   ru   r   r   r   r   r   r   r   r   r  r  r[  r  r  rv  r  r   r   r  r  r  r  r  r   r  r  rP  rd  rf  rr  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r  r  rL  rH  rG  rS  r  r  r  r}  r  r  r  r  r  r  r  r  r  r~  r  r  rn  rN  r4  r9  r=  r@  r
  rJ  r  r  rS  rU  rY  r^  rk  rm  ro  rr  rv  r  r}  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  not_invnegrr   r  r  r  r  r  r  r  r  r  r  r  r  r  r/  r
  r  r  r  r	  rS  r  r  r  r  r  matmulr"  r}   ltler  negegtis_r'  r  and_truedivfloordivrH  modrG  or_rw  rshiftr2  xorr.  r/  r0  r9  r;  r<  rI  rJ  rL  rM  rS  rT  compilefindallrq  	frozensetrr  rp  rt  r}  r  r^  r  r  r_  r  r  r  r  rR  r  r`  r  r^  r]  ra  rz  rd  rf  r  r  r  r  r  r  r  r  r  rN   rN   rN   rO   <module>   s  
(@D











	 
       !"	 3(XnI2$     z[[ p .#<0ac      : Jm 7   yC7 
   xpb ]*     {3      <)". ,0 @$.
:J$*  $P#3o, "2
  _2 K&

	 E 	>Q 1D^  s 	  j  b[]I(67+6Fs