a
    ûb®{ ã                   @   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d d dlZ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 d dlmZ d dlmZ d dlmZ zd dlZW n eyÄ   d dlZY n0 dd	lmZ dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ zd dl m!Z! W n  eyV   d dl"m#Z! Y n0 ej$dk Z%ddddddœZ&dddddœZ'dd iZ(g d!¢Z)e*g d"¢ƒZ+d#d$ij,Z-G d%d&„ d&eƒZ.d'd(„ Z/G d)d*„ d*eƒZ0G d+d,„ d,e0ƒZ1dRd-d.„Z2G d/d0„ d0e1ƒZ3G d1d2„ d2e0ƒZ4G d3d4„ d4eƒZ5G d5d6„ d6eƒZ6G d7d8„ d8eƒZ7ejeeeed9 e 8d: 9d;¡ej:¡j;Z<e 8d< =d=¡¡j;Z>e 8d>¡j?Z@e 8d?¡jAZBG d@dA„ dAeƒZCG dBdC„ dCeƒZDG dDdE„ dEeƒZEdFdG„ ZFG dHdI„ dIeƒZGG dJdK„ dKeƒZHG dLdM„ dMeƒZIG dNdO„ dOeƒZJG dPdQ„ dQeƒZKdS )Sé    )Úabsolute_importN)ÚosÚreÚoperatorÚtextwrapÚTemplateÚNamingÚOptionsÚStringEncodingÚUtilsÚSourceDescriptorÚStringIOTreeÚ
DebugFlagsÚ
basestringÚdefaultdictÚclosingÚpartial)r   )r   )r   )r   é   )r   )r	   )r   )r
   )ÚVersioné   )r   )r   )r   )r   )Ústr)r   é   )zPY_MAJOR_VERSION < 3r   )úPY_MAJOR_VERSION >= 3r   )r   Úrange)r   Úinput)ÚbytesÚunicoder   ÚxrangeÚ	raw_inputz&PyInt_Typez&PyLong_Typez&PyFloat_Typez&PyWrapperDescr_Type)Zpy_intZpy_longZpy_floatZwrapper_descriptorZPyTypeObjectZPyHeapTypeObject)Ú
breakpointÚ
__loader__Ú__spec__ÚBlockingIOErrorÚBrokenPipeErrorÚChildProcessErrorÚConnectionAbortedErrorÚConnectionErrorÚConnectionRefusedErrorÚConnectionResetErrorÚFileExistsErrorÚFileNotFoundErrorÚInterruptedErrorÚIsADirectoryErrorÚModuleNotFoundErrorÚNotADirectoryErrorÚPermissionErrorÚProcessLookupErrorÚRecursionErrorÚResourceWarningÚTimeoutErrorÚ__build_class__ÚasciiÚ
memoryviewZWindowsErrorÚ_)Z	__cinit__Z__dealloc__Z__richcmp__Ú__next__Ú	__await__Ú	__aiter__Ú	__anext__Z__getreadbuffer__Z__getwritebuffer__Z__getsegcount__Z__getcharbuffer__Z__getbuffer__Z__releasebuffer__ÚinlineZCYTHON_INLINEc                   @   sJ   e Zd ZdZdZdZdZdZddd	„Zd
d„ Z	dd„ Z
dd„ Zdd„ ZdS )ÚIncludeCodez]
    An include file and/or verbatim C code to be included in the
    generated sources.
    r   r   r   NTFc                 C   sš   | j | _t| ƒ j d7  _ i | _|rb|d dkrR|d dkrRd |¡| jd< d}nd |¡| jd< |rr|| j| j< |r€| j| _n|rŽ| j| _n| j| _d S )	Nr   r   ú<éÿÿÿÿú>z#include {0}Fz#include "{0}")	ÚcounterÚorderÚtypeÚpiecesÚformatÚINITIALÚlocationÚLATEÚEARLY)ÚselfÚincludeZverbatimZlateÚinitial© rM   úd/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/Cython/Compiler/Code.pyÚ__init__–   s    

zIncludeCode.__init__c                 C   s<   ||v r0|| }t | j|jƒ|_|j | j¡ n| ||< dS )z˜
        Insert `self` in dict `d` with key `key`. If that key already
        exists, update the attributes of the existing value with `self`.
        N)ÚminrG   rD   Úupdate)rJ   ÚdÚkeyÚotherrM   rM   rN   Údict_update¬   s
    zIncludeCode.dict_updatec                 C   s   | j S ©N)rB   ©rJ   rM   rM   rN   Úsortkey¸   s    zIncludeCode.sortkeyc                 C   s   | j  d¡S )zˆ
        Return the main piece of C code, corresponding to the include
        file. If there was no include file, return None.
        r   )rD   ÚgetrW   rM   rM   rN   Ú	mainpiece»   s    zIncludeCode.mainpiecec                 C   s$   t | jƒD ]}| | j| ¡ q
d S rV   )ÚsortedrD   Úputln)rJ   ÚcodeÚkrM   rM   rN   ÚwriteÂ   s    zIncludeCode.write)NNTF)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rF   rI   rH   rA   rO   rU   rX   rZ   r_   rM   rM   rM   rN   r=   |   s   
r=   c                  C   s*   t j t j t j t¡¡¡} t j | d¡S )NZUtility)r   ÚpathÚdirnameÚabspathÚ__file__Újoin)Z
Cython_dirrM   rM   rN   Úget_utility_dirÈ   s    ri   c                   @   sŽ   e Zd ZdZdZi Zeddd„ƒZedd„ ƒZeddd	„ƒZ	edi fd
d„ƒZ
eddd„ƒZe d¡jfdd„Zdd„ Zdd„ Zddd„ZdS )ÚUtilityCodeBaseaæ  
    Support for loading utility code from a file.

    Code sections in the file can be specified as follows:

        ##### MyUtility.proto #####

        [proto declarations]

        ##### MyUtility.init #####

        [code run at module initialization]

        ##### MyUtility #####
        #@requires: MyOtherUtility
        #@substitute: naming

        [definitions]

    for prototypes and implementation respectively.  For non-python or
    -cython files backslashes should be used instead.  5 to 30 comment
    characters may be used on either side.

    If the @cname decorator is not used and this is a CythonUtilityCode,
    one should pass in the 'name' keyword argument to be used for name
    mangling of such entries.
    FNc              
   C   s"  |d u rd S d  |¡}|rŒd|v rŒ|d tdgƒkrŒ|d= zt|ƒ ttƒ¡}W n: ttfyŠ } ztd|||f ƒ‚W Y d }~n
d }~0 0 d| | }|dkrª||d< n0|dkr¼||d< n|d	 }t	rÒ| 
d
¡}|||< |r|d	 }| ¡ D ],\}	}
t	r|	 
d
¡}	| |	tƒ ¡ |
¡ qðd S )NÚ
Ú
substituteZnamingz@Error parsing templated utility code of type '%s' at line %d: %sÚprotor   Úimplr   r   ÚASCII)rh   Úsetr   rl   Úvarsr   ÚKeyErrorÚ
ValueErrorÚRuntimeErrorÚKEYWORDS_MUST_BE_BYTESÚencodeÚitemsÚ
setdefaultrQ   )ÚclsÚutilityrC   ÚlinesÚbegin_linenoÚtagsr]   ÚeZall_tagsÚnameÚvaluesrM   rM   rN   Ú_add_utilityï   s4    
ÿ



zUtilityCodeBase._add_utilityc                 C   s  | j  |¡}|r|S tj tƒ |¡}tj |¡\}}|dv r\d}tt 	d¡j
dƒ}tjj}n(d}tt 	d¡j
dƒ}tt 	d¡j
dƒ}t 	d	d
|i ¡j}	t 	d¡j}
ttj|ddƒ}| ¡ }W d   ƒ n1 sÔ0    Y  tdd„ ƒ}g }ttƒ}d  }}d}t|ƒD ]¼\}}|	|ƒ}|r²| d¡rŒ|  |||||¡ |d }|d d …= | ¡  | d¡}|
|ƒ}|r~| ¡ \}}nd}|| }n$|| d¡  | d¡¡ | d¡ n| |||ƒƒ¡ q
|d u rÚtdƒ‚|  |||||¡ t|ƒ}|| j |< |S )N)z.pyxz.pyz.pxdz.pxiú#z^\s*#(?!\s*cython\s*:).*Ú ú/z^\s*//.*|/\*[^*]*\*/z	\s+(\\?)$z\1zd^%(C)s{5,30}\s*(?P<name>(?:\w|\.)+)\s*%(C)s{5,30}|^%(C)s+@(?P<tag>\w+)\s*:\s*(?P<value>(?:\w|[.:])+)ÚCz,(.+)[.](proto(?:[.]\S+)?|impl|init|cleanup)$úUTF-8)Úencodingc                   S   s
   d d i gS rV   rM   rM   rM   rM   rN   Ú<lambda>*  ó    z:UtilityCodeBase.load_utilities_from_file.<locals>.<lambda>r   r   r   rn   ÚtagÚvaluezEmpty utility code file)Ú_utility_cacherY   r   rd   rh   ri   Úsplitextr   r   ÚcompileÚsubr
   Z_unicodeÚrstripÚmatchr   r   Zopen_source_fileÚ	readlinesr   rp   Ú	enumerateÚgroupr   ÚclearÚgroupsÚaddÚappendrs   Údict)ry   rd   Ú	utilitiesÚfilenamer7   ÚextÚcommentÚstrip_commentsr   Zmatch_specialZ
match_typeÚfZ	all_linesr{   r}   rz   rC   r|   ÚlinenoÚlineÚmr   ÚmtyperM   rM   rN   Úload_utilities_from_file  s`    
þÿ&




z(UtilityCodeBase.load_utilities_from_filec                    sþ  d|v r|  dd¡\‰}ˆsætƒ ‰|d ‰zt ˆ¡}W nj ty¢   ddl}t}|j‰ t| 	ˆ ¡ƒ(}‡ ‡fdd„| 
¡ D ƒ}W d  ƒ n1 s”0    Y  Y n0 ‡fdd„|D ƒ}|sÆtd	| ƒ‚t|ƒdkrÞtd
| ƒ‚|d ‰ˆ ˆ¡}	|	| \}
}}|r¢| ¡ ‰| ¡ D ]Œ\}}||v r*q|dkrpˆrV‡‡‡fdd„t|ƒD ƒ}n‡‡fdd„t|ƒD ƒ}n&|s|d}nt|ƒdkr–t|ƒd }|||< q|
dur´|
|d< |durÆ||d< d|vrØ||d< d|vrðˆrðˆ|d< ˆf i |¤ŽS )a  
        Load utility code from a file specified by from_file (relative to
        Cython/Utility) and name util_code_name.  If from_file is not given,
        load it from the file util_code_name.*.  There should be only one
        file matched by this pattern.
        z::r   Ú.r   Nc                    s,   g | ]$}t j ˆ |¡ ˆ¡rt j |¡‘qS rM   )r   rd   rh   Ú
startswithÚbasename)Ú.0r   )ÚarchiveÚutility_dirrM   rN   Ú
<listcomp>h  s   þz(UtilityCodeBase.load.<locals>.<listcomp>c                    s   g | ]}|  ˆ ¡r|‘qS rM   )r¦   )r¨   r›   )ÚprefixrM   rN   r«   k  s   
ÿz No match found for utility code z4More than one filename match found for utility code Úrequiresc                    s    g | ]}ˆ j |ˆfi ˆ¤Ž‘qS rM   )Úload©r¨   Údep)ry   Ú	from_fileÚorig_kwargsrM   rN   r«   ~  s   ÿc                    s   g | ]}ˆ   |ˆ¡‘qS rM   )Úload_cachedr¯   )ry   r±   rM   rN   r«   ‚  s   ÿrm   rn   r   Úfile)Úrsplitri   r   ÚlistdirÚOSErrorÚzipfiler    r©   r   ÚZipFileÚnamelistrs   Úlenr¤   Úcopyrw   r[   Úlist)ry   Úutil_code_namer±   ÚkwargsÚlistingr¸   ÚloaderÚfileobjÚfilesrš   rm   rn   r}   r   r€   rM   )r©   ry   r±   r²   r¬   rª   rN   r®   Q  sd    ÿ*


ÿÿ


zUtilityCodeBase.loadc                 C   s@   | ||f}z
|| W S  t y&   Y n0 |  ||¡ }||< |S )z`
        Calls .load(), but using a per-type cache based on utility name and file name.
        )rr   r®   )ry   Úutility_code_namer±   Z_UtilityCodeBase__cacherS   r]   rM   rM   rN   r³   –  s    

zUtilityCodeBase.load_cachedc                 K   s6   | j ||fi |¤Ž}|j|j }}| |¡| |¡fS )zR
        Load a utility code as a string. Returns (proto, implementation)
        )r®   rm   rn   Úformat_code)ry   r¾   r±   r¿   Úutilrm   rn   rM   rM   rN   Úload_as_string£  s    zUtilityCodeBase.load_as_stringz\n\n+c                 C   s   |r|d|  ¡ ƒd }|S )z3
        Format a code section for output.
        rk   z

©Ústrip)rJ   Zcode_stringZreplace_empty_linesrM   rM   rN   rÅ   ¬  s    zUtilityCodeBase.format_codec                 C   s   dt | ƒj| jf S )Nz<%s(%s)>)rC   r`   r   rW   rM   rM   rN   Ú__str__´  s    zUtilityCodeBase.__str__c                 K   s   d S rV   rM   )rJ   r¿   rM   rM   rN   Úget_tree·  s    zUtilityCodeBase.get_treec                 C   s   | S rV   rM   )rJ   ZmemodictrM   rM   rN   Ú__deepcopy__º  s    zUtilityCodeBase.__deepcopy__)N)N)N)N)r`   ra   rb   rc   Zis_cython_utilityrŒ   Úclassmethodr   r¤   r®   r³   rÇ   r   rŽ   r   rÅ   rÊ   rË   rÌ   rM   rM   rM   rN   rj   Ï   s"   !
?Drj   c                   @   s\   e Zd ZdZd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S )ÚUtilityCodeaF  
    Stores utility code to add during code generation.

    See GlobalState.put_utility_code.

    hashes/equals by instance

    proto           C prototypes
    impl            implementation code
    init            code to call on module initialization
    requires        utility code dependencies
    proto_block     the place in the resulting file where the prototype should
                    end up
    name            name of the utility code (or None)
    file            filename of the utility code file this utility was loaded
                    from (or None)
    NÚutility_code_protoc	           	      C   s@   || _ || _|| _|| _|| _i | _g | _|| _|| _|| _	d S rV   )
rm   rn   ÚinitÚcleanupr­   Ú_cacheÚspecialize_listÚproto_blockr   r´   )	rJ   rm   rn   rÐ   rÑ   r­   rÔ   r   r´   rM   rM   rN   rO   Ò  s    zUtilityCode.__init__c                 C   s   t | j| jfƒS rV   )Úhashrm   rn   rW   rM   rM   rN   Ú__hash__à  s    zUtilityCode.__hash__c                 C   sj   | |u rdS t | ƒt |ƒ }}||ur>t||ƒs>t| |ƒs>dS t| dd ƒ}t|dd ƒ}|| jf||jfkS )NTFrm   )rC   Ú
isinstanceÚgetattrrn   )rJ   rT   Ú	self_typeZ
other_typeZ
self_protoZother_protorM   rM   rN   Ú__eq__ã  s    zUtilityCode.__eq__c                 C   s   |du rdS || S ©zY
        Format a string in this utility code with context. If None, do nothing.
        NrM   ©rJ   ÚsÚcontextrM   rM   rN   Únone_or_subî  s    zUtilityCode.none_or_subc                    sæ   | j }|d ur6| ¡ ˆ d< | ¡ ˆ d< d|ˆ d f }ttˆ  ¡ ƒƒ}z| j| W S  tyà   | jd u rpd }n‡ fdd„| jD ƒ}t	|  
| jˆ ¡|  
| jˆ ¡|  
| jˆ ¡|  
| jˆ ¡|| j|ƒ }| j|< | j |¡ | Y S 0 d S )NrC   Ú	type_namez%s[%s]c                    s   g | ]}|  ˆ ¡‘qS rM   )Ú
specialize)r¨   Úr©ÚdatarM   rN   r«     r‰   z*UtilityCode.specialize.<locals>.<listcomp>)r   Zempty_declaration_codeZspecialization_nameÚtupler[   rw   rÒ   rr   r­   rÎ   rß   rm   rn   rÐ   rÑ   rÔ   rÓ   r˜   )rJ   Z
pyrex_typerä   r   rS   r­   rÝ   rM   rã   rN   rá   ö  s.    
ù
zUtilityCode.specializec                    sT   d|vrd|vrd|fS i ‰‡ ‡fdd„}t  d||¡}d|vrHd|vsLJ ‚d|fS )zHReplace 'PYIDENT("xyz")' by a constant Python identifier cname.
        zPYIDENT(z
PYUNICODE(Fc                    sV   |   ¡ }zˆ| }W n< tyP   |\}}ˆ jt |¡|dkdj }ˆ|< Y n0 |S )NZIDENT©Ú
identifier)r–   rr   Úget_py_string_constr
   ÚEncodedStringÚcname)ÚmatchobjrS   rê   Zstr_typer   ©ÚoutputÚreplacementsrM   rN   Úexternalise  s    ÿz8UtilityCode.inject_string_constants.<locals>.externalisezPY(IDENT|UNICODE)\("([^"]+)"\)T©r   r   ©rJ   rn   rí   rï   rM   rì   rN   Úinject_string_constants  s    
z#UtilityCode.inject_string_constantsc                    s>   d|vrd|fS ‡ fdd„}t  d||¡}d|vs6J ‚d|fS )zVReplace 'UNBOUND_METHOD(type, "name")' by a constant Python identifier cname.
        zCALL_UNBOUND_METHOD(Fc                    s`   |   ¡ \}}}}|r0dd„ |dd …  d¡D ƒng }t|ƒdk sPJ dt|ƒ ƒ‚ˆ  ||||¡S )Nc                 S   s   g | ]}|  ¡ ‘qS rM   rÈ   )r¨   ÚargrM   rM   rN   r«   0  r‰   zKUtilityCode.inject_unbound_methods.<locals>.externalise.<locals>.<listcomp>r   ú,é   z8CALL_UNBOUND_METHOD() does not support %d call arguments)r–   Úsplitr»   Úcached_unbound_method_call_code)rë   Ú
type_cnameÚmethod_nameÚ	obj_cnameÚargs©rí   rM   rN   rï   .  s    $z7UtilityCode.inject_unbound_methods.<locals>.externalisezMCALL_UNBOUND_METHOD\(([a-zA-Z_]+),\s*"([^"]+)",\s*([^),]+)((?:,\s*[^),]+)*)\)Trð   rñ   rM   rü   rN   Úinject_unbound_methods(  s    úz"UtilityCode.inject_unbound_methodsc                 C   s2   d|vr|S dd„ }t  d||¡}d|vs.J ‚|S )z<Replace CSTRING('''xyz''') by a C compatible string
        zCSTRING(c                 S   s*   |   d¡ dd¡}d dd„ | ¡ D ƒ¡S )Nr   ú"rƒ   c                 s   s:   | ]2}|  d ¡r|  d¡r"d| nd|dd…  V  qdS )ú\z\\z"%s\n"
z"%s"
Nr?   )Úendswith©r¨   r¡   rM   rM   rN   Ú	<genexpr>G  s   ÿzCUtilityCode.wrap_c_strings.<locals>.split_string.<locals>.<genexpr>)r”   Úreplacerh   Ú
splitlines)rë   ÚcontentrM   rM   rN   Úsplit_stringE  s    
þz0UtilityCode.wrap_c_strings.<locals>.split_stringz)CSTRING\(\s*"""([^"]*(?:"[^"]+)*)"""\s*\)rð   )rJ   rn   r  rM   rM   rN   Úwrap_c_strings?  s    zUtilityCode.wrap_c_stringsc                 C   sš  | j r| j D ]}| |¡ q| jrV|| j }| d| j ¡ | |  | j¡d| j ¡ | jrÌ|  |  	| j¡¡}|  
||¡\}}|  ||¡\}}|d }| d| j ¡ |sÂ|sÂ| |d| j ¡ n
| |¡ | jr6|d }| d| j ¡ t| jtƒr| |  | j¡¡ n|  ||j¡ | | |j¡¡ | ¡  | jr–tjr–|d }| d	| j ¡ t| jtƒrˆ| |  | j¡d
| j ¡ n|  ||j¡ d S )Nz/* %s.proto */z%s_protoÚutility_code_defz/* %s */z%s_implÚinit_globalsz/* %s.init */Úcleanup_globalsz/* %s.cleanup */z
%s_cleanup)r­   Úuse_utility_coderm   rÔ   r\   r   Úput_or_includerÅ   rn   r  rò   rý   ÚputrÐ   r×   r   Ú
module_posÚerror_goto_if_PyErrrÑ   r	   Úgenerate_cleanup_code)rJ   rí   Ú
dependencyÚwriterrn   Zis_specialised1Zis_specialised2rM   rM   rN   Úput_codeO  sF    

ÿ

þzUtilityCode.put_code)NNNNNrÏ   NN)N)r`   ra   rb   rc   rO   rÖ   rÚ   rß   rá   rò   rý   r  r  rM   rM   rM   rN   rÎ   ¿  s     ÿ

rÎ   c                 C   sF   | sdS |rd||f |d< n|r*||d< ddl m} || fi |¤ŽS )z+Run tempita on string s with given context.Nz%s:%sZ__namer   ©r   )ÚTempitar   )rÝ   rÞ   r´   r   r   rM   rM   rN   Úsub_tempitaw  s    r  c                       s:   e Zd Zd‡ fdd„	Zeddi fdd„ƒZdd„ Z‡  ZS )	ÚTempitaUtilityCodeNc                    s\   |d u ri }t ||||ƒ}t ||||ƒ}t ||||ƒ}tt| ƒj||f|||dœ|¤Ž d S )N)rÐ   r   r´   )r  Úsuperr  rO   )rJ   r   rm   rn   rÐ   r´   rÞ   r¿   ©Ú	__class__rM   rN   rO   †  s    
ÿÿÿzTempitaUtilityCode.__init__c                 C   sn   |rt t| ¡ ƒƒnd }t|ƒd us(J ‚| |||f}z
|| W S  tyP   Y n0 | j|||d }||< |S )N)rÞ   )rå   r[   rw   rÕ   rr   r®   )ry   rÄ   r±   rÞ   Z_TempitaUtilityCode__cacheZcontext_keyrS   r]   rM   rM   rN   r³     s    
zTempitaUtilityCode.load_cachedc                 C   s   |du rdS t ||| j| jƒS rÛ   )r  r´   r   rÜ   rM   rM   rN   rß   ›  s    zTempitaUtilityCode.none_or_sub)NNNNNN)r`   ra   rb   rO   rÍ   r³   rß   Ú__classcell__rM   rM   r  rN   r  …  s   	r  c                   @   s(   e Zd ZdZdZ dZdd„ Zdd„ ZdS )ÚLazyUtilityCodezŠ
    Utility code that calls a callback with the root code writer when
    available. Useful when you only have 'env' but not 'code'.
    z<lazy>Nc                 C   s
   || _ d S rV   )Úcallback)rJ   r  rM   rM   rN   rO   ¬  s    zLazyUtilityCode.__init__c                 C   s   |   |j¡}| |¡ d S rV   )r  Ú
rootwriterr  )rJ   Úglobalstaterz   rM   rM   rN   r  ¯  s    zLazyUtilityCode.put_code)r`   ra   rb   rc   r­   rO   r  rM   rM   rM   rN   r  ¤  s
   r  c                   @   sÊ   e Zd Zeƒ dfdd„Zdd„ Zd1dd„Zd2d	d
„Zdd„ Zdd„ Z	dd„ Z
dd„ Zdd„ Zdd„ Zdd„ Zdd„ Zdd„ Zd3dd „Zd!d"„ Zd#d$„ Zd%d&„ Zd'd(„ Zd)d*„ Zd+d,„ Zd-d.„ Zd/d0„ ZdS )4ÚFunctionStateNc                 C   s¤   || _ || _|| _d | _d| _tƒ | _|  ¡ | _|  	¡  d | _
d | _g | _d| _d | _d | _d| _d| _g | _i | _i | _tƒ | _d| _d | _g | _d| _d| _d S )Nr   FT)Únames_takenÚownerÚscopeÚerror_labelÚlabel_counterrp   Úlabels_usedÚ	new_labelÚreturn_labelÚnew_error_labelÚcontinue_labelÚbreak_labelÚyield_labelsZin_try_finallyZexc_varsZcurrent_exceptÚ	can_traceÚ	gil_ownedÚtemps_allocatedÚ
temps_freeÚtemps_used_typeÚzombie_tempsÚtemp_counterÚclosure_tempsÚcollect_temps_stackÚshould_declare_error_indicatorÚuses_error_indicator)rJ   r"  r!  r#  rM   rM   rN   rO   Á  s2    
zFunctionState.__init__c                 C   sB   | j r>|  ¡ }|r>d| jjd dd„ t|ƒD ƒ¡f }t|ƒ‚d S )Nz-TEMPGUARD: Temps left over at end of '%s': %sú, c                 S   s   g | ]\}}}d ||f ‘qS )z%s [%s]rM   )r¨   r   ÚctypeZ	is_pytemprM   rM   rN   r«   î  s   ÿz/FunctionState.validate_exit.<locals>.<listcomp>)r/  Útemps_in_user#  r   rh   r[   rt   )rJ   Z	leftoversÚmsgrM   rM   rN   Úvalidate_exité  s    þzFunctionState.validate_exitc                 C   s6   | j }|d | _ dtj|f }|d ur2|d| 7 }|S )Nr   ú%s%dr7   )r%  r   Zlabel_prefix)rJ   r   ÚnÚlabelrM   rM   rN   r'  ÷  s    
zFunctionState.new_labelÚyieldc                 C   s0   |   d| ¡}t| jƒd |f}| j |¡ |S )Nzresume_from_%sr   )r'  r»   r,  r˜   )rJ   Z	expr_typer?  Znum_and_labelrM   rM   rN   Únew_yield_labelÿ  s    zFunctionState.new_yield_labelc                 C   s   | j }|  d¡| _ |S )NÚerror)r$  r'  )rJ   Zold_err_lblrM   rM   rN   r)    s    zFunctionState.new_error_labelc                 C   s   | j | jfS rV   ©r*  r+  rW   rM   rM   rN   Úget_loop_labels
  s    þzFunctionState.get_loop_labelsc                 C   s   |\| _ | _d S rV   rC  ©rJ   ÚlabelsrM   rM   rN   Úset_loop_labels  s    ÿÿzFunctionState.set_loop_labelsc                 C   s&   |   ¡ }|  |  d¡|  d¡f¡ |S )NÚcontinueÚbreak)rD  rG  r'  )rJ   Ú
old_labelsrM   rM   rN   Únew_loop_labels  s    ÿÿzFunctionState.new_loop_labelsc                 C   s   | j | j| j| jfS rV   ©r*  r+  r(  r$  rW   rM   rM   rN   Úget_all_labels  s
    üzFunctionState.get_all_labelsc                 C   s   |\| _ | _| _| _d S rV   rL  rE  rM   rM   rN   Úset_all_labels!  s    ýýzFunctionState.set_all_labelsc                 C   sR   |   ¡ }g }t|g d¢ƒD ](\}}|r8| |  |¡¡ q| |¡ q|  |¡ |S )N)rH  rI  ÚreturnrB  )rM  Úzipr˜   r'  rN  )rJ   rJ  Z
new_labelsZ	old_labelr   rM   rM   rN   Úall_new_labels'  s    
zFunctionState.all_new_labelsc                 C   s   | j  |¡ d S rV   )r&  r—   ©rJ   ÚlblrM   rM   rN   Ú	use_label2  s    zFunctionState.use_labelc                 C   s
   || j v S rV   )r&  rR  rM   rM   rN   Ú
label_used5  s    zFunctionState.label_usedFTc                 C   s:  |j r|js|j}n0|jr(|js(|j}n|jrDddlm} | |¡}|j	sT|j
sTd}| j ||f¡}|r”|dur”|d r”|d  ¡ }|d  |¡ nP|  jd7  _dtj| jf }|| jvr”qÀq”| j ||||f¡ |sä| j |¡ ||f| j|< tjr| j d|||rdnd	f ¡ | jr6| jd
  ||f¡ |S )aõ  
        Allocates a temporary (which may create a new one or get a previously
        allocated and released one of the same type). Type is simply registered
        and handed back, but will usually be a PyrexType.

        If type.is_pyobject, manage_ref comes into play. If manage_ref is set to
        True, the temp will be decref-ed on return statements and in exception
        handling clauses. Otherwise the caller has to deal with any reference
        counting of the variable.

        If not type.is_pyobject, then manage_ref will be ignored, but it
        still has to be passed. It is recommended to pass False by convention
        if it is known that type will never be a Python object.

        static=True marks the temporary declaration with "static".
        This is only used when allocating backing store for a module-level
        C array literals.

        if reusable=False, the temp will not be reused after release.

        A C string referring to the variable is returned.
        r   )Ú
PyrexTypesFNr   r=  z/* %s allocated (%s)%s */rƒ   ú	 - zombier?   )Úis_constZis_referenceZconst_base_typeZis_fake_referenceZref_base_typeZis_cfunctionrƒ   rV  Z
c_ptr_typeÚis_pyobjectÚis_memoryviewslicer0  rY   ÚpopÚremover3  r   Úcodewriter_temp_prefixr!  r/  r˜   r2  r—   r1  r   Údebug_temp_code_commentsr"  r\   r5  )rJ   rC   Ú
manage_refÚstaticZreusablerV  ÚfreelistÚresultrM   rM   rN   Úallocate_temp:  s2    
 zFunctionState.allocate_tempc                 C   s¨   | j | \}}| j ||f¡}|du r>g tƒ f}|| j||f< ||d v rVtd| ƒ‚|| jvrn|d  |¡ |d  |¡ tj	r¤| j
 d||| jv ršdndf ¡ dS )zv
        Releases a temporary so that it can be reused by other code needing
        a temp of the same type.
        Nr   zTemp %s freed twice!r   z/* %s released %s*/rW  rƒ   )r1  r0  rY   rp   rt   r2  r˜   r—   r   r^  r"  r\   )rJ   r   rC   r_  ra  rM   rM   rN   Úrelease_tempr  s    

ÿzFunctionState.release_tempc                 C   sV   g }| j D ]F\}}}}| j ||f¡}|du s:||d vr
| |||oJ|jf¡ q
|S )zxReturn a list of (cname,type,manage_ref) tuples of temp names and their type
        that are currently in use.
        Nr   )r/  r0  rY   r˜   rY  )rJ   Úusedr   rC   r_  r`  ra  rM   rM   rN   r:  …  s    zFunctionState.temps_in_usec                 C   s   dd„ |   ¡ D ƒS )zÀReturn a list of (cname,type) tuples of temp names and their type
        that are currently in use. This includes only temps of a
        Python object type which owns its reference.
        c                 S   s$   g | ]\}}}|r|j r||f‘qS rM   )rY  )r¨   r   rC   r_  rM   rM   rN   r«   •  s   
þz9FunctionState.temps_holding_reference.<locals>.<listcomp>)r:  rW   rM   rM   rN   Útemps_holding_reference  s    ÿz%FunctionState.temps_holding_referencec                 C   s   dd„ | j D ƒS )zRReturn a list of (cname, type) tuples of refcount-managed Python objects.
        c                 S   s    g | ]\}}}}|r||f‘qS rM   rM   )r¨   rê   rC   r_  r`  rM   rM   rN   r«   œ  s   
þz3FunctionState.all_managed_temps.<locals>.<listcomp>)r/  rW   rM   rM   rN   Úall_managed_temps™  s    ÿzFunctionState.all_managed_tempsc                 C   s   t dd„ | j ¡ D ƒƒS )zàReturn a list of (cname, type) tuples of refcount-managed Python
        objects that are not currently in use.  This is used by
        try-except and try-finally blocks to clean up temps in the
        error case.
        c                 S   s.   g | ]&\\}}}|r|d  D ]}||f‘qqS )r   rM   )r¨   rC   r_  ra  rê   rM   rM   rN   r«   ¦  s   þz8FunctionState.all_free_managed_temps.<locals>.<listcomp>)r[   r0  rw   rW   rM   rM   rN   Úall_free_managed_temps   s    þz$FunctionState.all_free_managed_tempsc                 C   s   | j  tƒ ¡ dS )zJ
        Useful to find out which temps were used in a code block
        N)r5  r˜   rp   rW   rM   rM   rN   Ústart_collecting_temps¬  s    z$FunctionState.start_collecting_tempsc                 C   s
   | j  ¡ S rV   )r5  r[  rW   rM   rM   rN   Ústop_collecting_temps²  s    z#FunctionState.stop_collecting_tempsc                 C   s   t |ƒ| _d S rV   )ÚClosureTempAllocatorr4  ©rJ   r#  rM   rM   rN   Úinit_closure_tempsµ  s    z FunctionState.init_closure_temps)N)r@  )FT)r`   ra   rb   rp   rO   r<  r'  rA  r)  rD  rG  rK  rM  rN  rQ  rT  rU  rc  rd  r:  rf  rg  rh  ri  rj  rm  rM   rM   rM   rN   r   ´  s,   (


8	r   c                   @   s   e Zd ZdZddd„ZdS )ÚNumConstzâGlobal info about a Python number constant held by GlobalState.

    cname       string
    value       string
    py_type     string     int, long, float
    value_code  string     evaluation code if different from value
    Nc                 C   s    || _ || _|| _|p|| _d S rV   )rê   r‹   Úpy_typeÚ
value_code)rJ   rê   r‹   ro  rp  rM   rM   rN   rO   Â  s    zNumConst.__init__)N©r`   ra   rb   rc   rO   rM   rM   rM   rN   rn  ¹  s   rn  c                   @   s   e Zd ZdZdd„ ZdS )ÚPyObjectConstz>Global info about a generic constant held by GlobalState.
    c                 C   s   || _ || _d S rV   )rê   rC   )rJ   rê   rC   rM   rM   rN   rO   Ï  s    zPyObjectConst.__init__Nrq  rM   rM   rM   rN   rr  É  s   rr  )Úpossible_unicode_identifierÚpossible_bytes_identifierÚreplace_identifierÚfind_alphanumss   (?![0-9])\w+$r5   z(?![0-9])\w+$ro   z[^a-zA-Z0-9_]+z([a-zA-Z0-9]+)c                   @   s*   e Zd ZdZdd„ Zdd„ Zd
dd	„ZdS )ÚStringConstz?Global info about a C string constant held by GlobalState.
    c                 C   s(   || _ || _t |¡| _d | _g | _d S rV   )rê   Útextr
   Zescape_byte_stringÚescaped_valueÚ
py_stringsÚpy_versions)rJ   rê   rx  Úbyte_stringrM   rM   rN   rO   â  s
    zStringConst.__init__c                 C   s*   |sddg| _ n|| j vr&| j  |¡ d S )Nr   rõ   )r{  r˜   )rJ   ÚversionrM   rM   rN   Úadd_py_versioné  s    
zStringConst.add_py_versionNFc                 C   sR  | j }| j}t|p|ƒ}|d u o$| }|d u r4d }n(| ¡ }|dv rNd }d }nd t|ƒ¡}||||f}	|d urz
||	 W S  tyŒ   Y q–0 ni | _ |r d}
n2|d u rÎt|tƒrÀtt	|ƒƒ}
qÒtt
|ƒƒ}
nd}
|
râtjd }ntj}|röd| }nd}d||r
dp|rd	pd
|| jttjƒd … f }t||||||
ƒ}|| j |	< |S )N)Úutf8zutf-8r5   Zusasciizus-asciirƒ   TFr   z_%sz	%s%s%s_%srÝ   ÚuÚb)rz  rx  ÚboolÚlowerrh   rv  rr   r×   r   rt  rs  r   Úinterned_prefixesZpy_const_prefixrê   r»   Úconst_prefixÚPyStringConst)rJ   r‡   rç   Úis_strÚpy3str_cstringrz  rx  Ú
is_unicodeZencoding_keyrS   Úinternr¬   Zencoding_prefixZpystring_cnameÚ	py_stringrM   rM   rN   rè   ï  sT    


üÿ
zStringConst.get_py_string_const)NFN)r`   ra   rb   rc   rO   r~  rè   rM   rM   rM   rN   rw  Û  s     ÿrw  c                   @   s"   e Zd ZdZddd„Zdd„ ZdS )	r†  zDGlobal info about a Python string constant held by GlobalState.
    FNc                 C   s(   || _ || _|| _|| _|| _|| _d S rV   )rê   rˆ  r‡   r‡  r‰  rŠ  )rJ   rê   r‡   r‰  r‡  rˆ  rŠ  rM   rM   rN   rO   4  s    zPyStringConst.__init__c                 C   s   | j |j k S rV   )rê   ©rJ   rT   rM   rM   rN   Ú__lt__=  s    zPyStringConst.__lt__)FNF)r`   ra   rb   rc   rO   r  rM   rM   rM   rN   r†  *  s
   	  ÿ
	r†  c                   @   s:  e Zd Zi Zg d¢ZdIdd„Zdd„ Zdd„ Zd	d
„ Zdd„ Z	dd„ Z
dJdd„ZdKdd„Zdd„ ZdLdd„ZdMdd„Zdd„ ZdNdd„Zdd „ Zd!d"„ ZdOd#d$„ZdPd%d&„Zd'd(„ Zd)d*„ ZdQd+d,„Zd-d.„ Zd/d0„ Zd1d2„ Zd3d4„ Zd5d6„ Zd7d8„ Zd9d:„ Zd;d<„ Z d=d>„ Z!d?d@„ Z"dAdB„ Z#dCdD„ Z$dEdF„ Z%dGdH„ Z&dS )RÚGlobalState)Zh_codeÚfilename_tableZutility_code_proto_before_typesZnumeric_typedefsZcomplex_type_declarationsZtype_declarationsrÏ   Zmodule_declarationsZtypeinfoZbefore_global_varÚ
global_varÚstring_declsÚdeclsZlate_includesZall_the_restÚpystring_tableÚcached_builtinsÚcached_constantsr	  Zinit_moduler
  Úcleanup_moduleZmain_methodr  ÚendNc                 C   s„   i | _ g | _i | _tƒ | _i | _d| _|| _|| _i | _	|| _
i | _i | _i | _i | _i | _g | _i | _tƒ | _| | ¡ || _d S )NF)r  Úfilename_listÚinput_file_contentsrp   Úutility_codesÚdeclared_cnamesZin_utility_code_generationÚcode_configÚcommon_utility_include_dirÚpartsÚmodule_nodeÚconst_cnames_usedÚstring_const_indexÚdedup_const_indexÚpyunicode_ptr_const_indexÚnum_const_indexÚpy_constantsÚcached_cmethodsÚinitialised_constantsÚset_global_stater  )rJ   r  rŸ  rœ  r  rM   rM   rN   rO   }  s(    
zGlobalState.__init__c                 C   s4  | j }| jD ]}| ¡ | j|< qtjs0| jd= n| jd }| ¡  | d¡ | jd }| ¡  | d¡ | d¡ | ¡  | 	d¡ | jd }| ¡  | d¡ | d¡ tj
sº| jd	= n&| jd	 }| ¡  | d¡ | d
¡ | jd }| d¡ | d¡ | jd }| jjr| d¡ | d¡ | d¡ d S )Nr”  z=static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {r•  rƒ   z>static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {Z__Pyx_InitCachedConstantsr	  z6static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) {r
  z:static CYTHON_SMALL_CODE void __Pyx_CleanupGlobals(void) {rÏ   z)/* --- Runtime support code (head) --- */r  z
#line 1 "cython_utility"
z"/* --- Runtime support code --- */)r  Úcode_layoutÚinsertion_pointrž  r	   Úcache_builtinsÚenter_cfunc_scoper\   Úput_declare_refcount_contextÚput_setup_refcount_contextr  rœ  Úemit_linenumsr_   )rJ   r  ÚpartÚwr]   rM   rM   rN   Úinitialize_main_c_code–  s@    





















z"GlobalState.initialize_main_c_codec                 C   s>   |   ¡  | jd }t dd¡}| | |j¡¡ | d¡ d S )Nr  ZTypeConversionszTypeConversion.crƒ   )Úclose_global_declsrž  r  r³   r  rÅ   rn   r\   )rJ   r]   rÆ   rM   rM   rN   Úfinalize_main_c_codeÀ  s
    
z GlobalState.finalize_main_c_codec                 C   s
   | j | S rV   )rž  )rJ   rS   rM   rM   rN   Ú__getitem__Ë  s    zGlobalState.__getitem__c                 C   sB  |   ¡  tjrV| jd }| d¡ | |j¡rD| |j¡ | d¡ | d¡ | ¡  | jd }| 	¡  | d¡ | |j¡rœ| |j¡ | 	¡  | d¡ | d¡ | ¡  | jd }| d¡ | |j¡rä| |j¡ | d¡ | d¡ | ¡  tj
r| jd }| d¡ | ¡  tj
r>| jd }| d¡ | ¡  d S )	Nr”  z	return 0;z
return -1;Ú}r•  r	  r
  r–  )Úgenerate_const_declarationsr	   r«  rž  r\   rU  r$  Ú	put_labelÚexit_cfunc_scopeÚput_finish_refcount_contextr  )rJ   r±  rM   rM   rN   r³  Ñ  sB    















zGlobalState.close_global_declsc                 C   s   | d   d|j ¡ d S )Nr  ústatic PyObject *%s;)r\   rê   ©rJ   ÚentryrM   rM   rN   Úput_pyobject_declú  s    zGlobalState.put_pyobject_declc                 C   s,   |d ur"|| j v rd S | j  |¡ | jd S )Nr•  )r§  r—   rž  ©rJ   ÚtargetrM   rM   rN   Úget_cached_constants_writerÿ  s
    
z'GlobalState.get_cached_constants_writerFc                 C   sB   |rdp
d}z| j ||f }W n ty<   |  ||¡}Y n0 |S )NÚlongÚint©r¤  rr   Únew_num_const)rJ   Ú	str_valueÚlongnessro  ÚcrM   rM   rN   Úget_int_const  s    zGlobalState.get_int_constc                 C   s8   z| j |df }W n  ty2   |  |d|¡}Y n0 |S )NÚfloatrÄ  )rJ   rÆ  rp  rÈ  rM   rM   rN   Úget_float_const  s
    zGlobalState.get_float_constrƒ   c                 C   sn   |d ur | j  |¡}|d ur |S |  ||¡}|d urX|tjkrX| jd }| d|j ¡ |d urj|| j |< |S )Nr
  zPy_CLEAR(%s);)r¢  rY   Únew_py_constr	   r  rž  r\   rê   )rJ   rC   r¬   Úcleanup_levelÚ	dedup_keyÚconstZcleanup_writerrM   rM   rN   Úget_py_const  s    ÿ

zGlobalState.get_py_constc                 C   sT   |j r| ¡ }n| ¡ }z| j| }W n tyD   |  ||¡}Y n0 | |¡ |S rV   )r‰  Ú
utf8encodeÚ
byteencoder¡  rr   Únew_string_constr~  )rJ   rx  Ú
py_versionr|  rÈ  rM   rM   rN   Úget_string_const%  s    

zGlobalState.get_string_constc                 C   sB   |j s
J ‚z| j| }W n$ ty<   |  ¡  }| j|< Y n0 |S rV   )r‰  r£  rr   Únew_const_cname)rJ   rx  rÈ  rM   rM   rN   Úget_pyunicode_ptr_const2  s    
z#GlobalState.get_pyunicode_ptr_constc                 C   s^   d }|r>|d ur>|  ¡ | ¡ kr>| j|dd}| j|dd}n
|  |¡}| |j|||¡}|S )Nrõ   )rÔ  r   )rÑ  rÒ  rÕ  rè   r‡   )rJ   rx  rç   r‡  Úunicode_valuerˆ  Zc_stringr‹  rM   rM   rN   rè   ;  s    ÿ

ÿzGlobalState.get_py_string_constc                 C   s   | j |ddS ©NTræ   ©rè   ©rJ   rx  rM   rM   rN   Úget_interned_identifierI  s    z#GlobalState.get_interned_identifierc                 C   s$   |   |¡}t|||ƒ}|| j|< |S rV   )Únew_string_const_cnamerw  r¡  )rJ   rx  r|  rê   rÈ  rM   rM   rN   rÓ  L  s    

zGlobalState.new_string_constc                 C   s,   |   ||¡}t||||ƒ}|| j||f< |S rV   )Únew_num_const_cnamern  r¤  )rJ   r‹   ro  rp  rê   rÈ  rM   rM   rN   rÅ  R  s    zGlobalState.new_num_constc                 C   s$   |   |¡}t||ƒ}| j |¡ |S rV   )rÖ  rr  r¥  r˜   )rJ   rC   r¬   rê   rÈ  rM   rM   rN   rÌ  X  s    

zGlobalState.new_py_constc                 C   s   |  dd¡}| j|dS )Nro   Úignore)r‹   )ÚdecoderÖ  )rJ   Zbytes_valuer‹   rM   rM   rN   rÝ  ^  s    z"GlobalState.new_string_const_cnamec                 C   sJ   |dkr|d7 }d}t j| }d||f }| dd¡ dd¡ d	d¡}|S )
NrÂ  ÚLrÃ  ú%s%sú+r7   ú-Zneg_r¥   )r   r„  r  )rJ   r‹   ro  r¬   rê   rM   rM   rN   rÞ  c  s    
zGlobalState.new_num_const_cnamec                 C   sv   t d|ƒd d…  d¡}| j}|}||v rL|| d  }||< d||f }q"d||< |rdtj| }ntj}d||f S )Nr7   é    r   z%s_%drâ  )ru  rÉ   r   r   r„  r…  )rJ   r¬   r‹   re  Zname_suffixrA   rM   rM   rN   rÖ  l  s    zGlobalState.new_const_cnamec              	   C   sL   ||f}z| j | }W n0 tyF   |  dd||f ¡ }| j |< Y n0 |S )NZumethodz%s_%s)r¦  rr   rÖ  )rJ   rø   rù   rS   rê   rM   rM   rN   Úget_cached_unbound_methodz  s    ÿz%GlobalState.get_cached_unbound_methodc                 C   sH   dt |ƒ }|  t |d¡¡ |  ||¡}|g| }d||d |¡f S )NzCallUnboundCMethod%dúObjectHandling.cz__Pyx_%s(&%s, %s)r8  )r»   r  rÎ   r³   ræ  rh   )rJ   rú   rø   rù   Z
arg_cnamesrÄ   Zcache_cnamerû   rM   rM   rN   r÷   ƒ  s    
ýz+GlobalState.cached_unbound_method_call_codec                 C   s¦   |j r¢|jr¢|  |j|¡r¢|  |¡ | jd }d }|jtv rzt|j \}}| d| ¡ |  	|j
t |¡|j¡ | d¡ |  	|j
t |j¡|j¡ |r¢| d¡ d S )Nr”  ú#if %sú#elseú#endif)Ú
is_builtinrX  Úshould_declarerê   r¾  rž  r   Únon_portable_builtins_mapr\   Úput_cached_builtin_initÚposr
   ré   )rJ   r½  r±  Ú	conditionÚreplacementrM   rM   rN   Úadd_cached_builtin_decl  s&    


þ
þz#GlobalState.add_cached_builtin_declc              	   C   sH   | j d }|  |¡j}|  t dd¡¡ | d|||| |¡f ¡ d S )Nr”  ZGetBuiltinNamerç  z*%s = __Pyx_GetBuiltinName(%s); if (!%s) %s)rž  rÜ  rê   r  rÎ   r³   r\   Ú
error_goto)rJ   rï  r   rê   r±  Zinterned_cnamerM   rM   rN   rî  ¢  s    

ÿüz#GlobalState.put_cached_builtin_initc                 C   s$   |   ¡  |  ¡  |  ¡  |  ¡  d S rV   )Úgenerate_cached_methods_declsÚgenerate_string_constantsÚgenerate_num_constantsÚgenerate_object_constant_declsrW   rM   rM   rN   r·  ­  s    z'GlobalState.generate_const_declarationsc                 C   sL   dd„ | j D ƒ}| ¡  | jd }|D ] \}}}| d|j |¡ ¡ q&d S )Nc                 S   s   g | ]}t |jƒ|j|f‘qS rM   ©r»   rê   ©r¨   rÈ  rM   rM   rN   r«   ´  s   ÿz>GlobalState.generate_object_constant_decls.<locals>.<listcomp>r’  z
static %s;)r¥  Úsortrž  r\   rC   Údeclaration_code)rJ   ÚconstsÚdecls_writerr7   rê   rÈ  rM   rM   rN   r÷  ³  s    ÿ
ÿz*GlobalState.generate_object_constant_declsc           	      C   sª   | j s
d S | jd }| jd }g }t| j  ¡ ƒD ]L\\}}}| |¡ |  t |¡¡j}| 	d||f ¡ | 	d||f ¡ q0t
jr¦| jd }|D ]}| 	d| ¡ q’d S )Nr’  r	  z4static __Pyx_CachedCFunction %s = {0, &%s, 0, 0, 0};z%s.type = (PyObject*)&%s;r
  zPy_CLEAR(%s.method);)r¦  rž  r[   rw   r˜   rÜ  r
   ré   rê   r\   r	   r  )	rJ   ÚdeclrÐ   Úcnamesrø   rù   rê   Zmethod_name_cnamerÑ   rM   rM   rN   rô  ¼  s$    


ÿÿ

z)GlobalState.generate_cached_methods_declsc                 C   s’  dd„ | j  ¡ D ƒ}| ¡  g }| jd }|D ]¢\}}}d}|jrvd|jvsVd|jvrvd}| dd|jv rnd	ppd
 ¡ | d|t |j¡f ¡ |rž| d¡ |j	d ur.|j	 ¡ D ]}| 
|jt|jƒ|f¡ q²q.t| j ¡ ƒD ]b\}}t |¡\}	}
|	r| d¡ | d||
f ¡ |	rà| d¡ | d||	f ¡ | d¡ qà|rŽ|  t dd¡¡ | ¡  | jd }| d¡ | dtj ¡ |D ]Æ\}}}|jr²|jr²|jdv r¸d}nd|j ¡  }| d|j ¡ |jr| d¡ | d|j|jj|jjddd|jf ¡ | d¡ | d|j||||j|j|jf ¡ |jrŒ| d¡ qŒ| d¡ | d¡ | jd }| d tj| | j¡f ¡ d S )!Nc                 S   s   g | ]}t |jƒ|j|f‘qS rM   rø  rù  rM   rM   rN   r«   Ò  r‰   z9GlobalState.generate_string_constants.<locals>.<listcomp>r‘  Fr   rõ   Tz#if PY_MAJOR_VERSION %s 3r>   z>=zstatic const char %s[] = "%s";rê  z#ifdef Py_UNICODE_WIDEz static Py_UNICODE %s[] = { %s };ré  ZInitStringszStringTools.cr“  rƒ   z$static __Pyx_StringTabEntry %s[] = {)ro   ÚUSASCIIzUS-ASCIIÚUTF8r†   Ú0z"%s"r»  z#if PY_MAJOR_VERSION >= 3z&{&%s, %s, sizeof(%s), %s, %d, %d, %d},r   r   z{0, 0, 0, 0, 0, 0, 0}z};r	  z"if (__Pyx_InitStrings(%s) < 0) %s;)r¡  r€   rú  rž  r{  r\   r
   Zsplit_string_literalry  rz  r˜   rê   r»   r[   r£  rw   Zencode_pyunicode_stringr  rÎ   r³   r   Zstringtab_cnamer‡  r‡   rƒ  rˆ  rŠ  r‰  ró  r  )rJ   Zc_constsrz  rý  r7   rê   rÈ  Zconditionalr‹  Zutf16_arrayZutf32_arrayr±  Zc_cnamer‡   r	  rM   rM   rN   rõ  Ñ  s’    
ÿÿ





ÿÿ
û
ù	



þÿz%GlobalState.generate_string_constantsc              
   C   sÈ   dd„ | j  ¡ D ƒ}| ¡  | jd }| jd }|D ]Ž\}}}}}}|j}	| d|	 ¡ |dkrfd}
n:|dkrtd	}
n,t |¡r„d
}
nt| 	d¡ƒdkrœd}
nd}
| d|	|
| | 
|	| j¡f ¡ q4d S )Nc                 S   s2   g | ]*}|j |jd  dkt|jƒ|j|j|f‘qS )r   rä  )ro  r‹   r»   rp  rù  rM   rM   rN   r«     s   ÿz6GlobalState.generate_num_constants.<locals>.<listcomp>r’  r	  r»  rÊ  zPyFloat_FromDouble(%s)rÂ  z%PyLong_FromString((char *)"%s", 0, 0)z$PyInt_FromString((char *)"%s", 0, 0)rä  é   zPyInt_FromLong(%sL)zPyInt_FromLong(%s)z%s = %s; %s)r¤  r€   rú  rž  rê   r\   r   Zlong_literalr»   ÚlstripÚerror_goto_if_nullr  )rJ   rü  rý  r	  ro  r7   r‹   rp  rÈ  rê   ÚfunctionrM   rM   rN   rö    s,    ÿ


þz"GlobalState.generate_num_constantsc                 C   sR   || j v r@| j | }t|jƒt|jƒks,J ‚|j|jks<J ‚dS || j |< dS d S )NFT)r›  r   rC   rÐ   )rJ   rê   r½  rT   rM   rM   rN   rì  :  s    


zGlobalState.should_declarec                 C   sN   |  ¡ }z| j| }W n2 tyH   t| jƒ}| j |¡ || j|< Y n0 |S rV   )Zget_filenametable_entryr  rr   r»   r˜  r˜   )rJ   Úsource_descr½  ÚindexrM   rM   rN   Úlookup_filenameH  s    
zGlobalState.lookup_filenamec              	   C   s„   z| j | W S  ty   Y n0 |jddd}z$dd„ |D ƒ}W t|dƒrh| ¡  nt|dƒrf| ¡  0 |sv| d¡ || j |< |S )Nro   rß  )r‡   Zerror_handlingc                 S   s(   g | ] }d |  ¡  dd¡ dd¡ ‘qS )z * z*/z.*[inserted by cython to avoid comment closer]/z/*z-/[inserted by cython to avoid comment start]*)r   r  r  rM   rM   rN   r«   Z  s   û
ÿýz7GlobalState.commented_file_contents.<locals>.<listcomp>Úcloserƒ   )r™  rr   Ú	get_linesÚhasattrr
  r˜   )rJ   r  Zsource_fileÚFrM   rM   rN   Úcommented_file_contentsR  s$    ÿû

ÿ


z#GlobalState.commented_file_contentsc                 C   s(   |r$|| j vr$| j  |¡ | | ¡ dS )a  
        Adds code to the C file. utility_code should
        a) implement __eq__/__hash__ for the purpose of knowing whether the same
           code has already been included
        b) implement put_code, which takes a globalstate instance

        See UtilityCode.
        N)rš  r—   r  )rJ   Úutility_coderM   rM   rN   r  k  s    	zGlobalState.use_utility_codec                 C   s4   |d u rd S |j r|  |j ¡ |jr0|  |j¡ d S rV   )r  r  Zutility_code_definitionr¼  rM   rM   rN   Úuse_entry_utility_codex  s    z"GlobalState.use_entry_utility_code)N)N)F)rƒ   NN)N)NFN)N)rƒ   )rƒ   rƒ   )'r`   ra   rb   Ú
directivesr©  rO   r²  r´  rµ  r³  r¾  rÁ  rÉ  rË  rÐ  rÕ  r×  rè   rÜ  rÓ  rÅ  rÌ  rÝ  rÞ  rÖ  ræ  r÷   rò  rî  r·  r÷  rô  rõ  rö  rì  r	  r  r  r  rM   rM   rM   rN   rŽ  A  sL   
*)



	  ÿ


	
		M
rŽ  c                    s2   | j ‰t ˆ¡‰ ‡ fdd„}‡fdd„}t||ƒS )Nc                    s
   ˆ | j ƒS rV   ©Ú	funcstaterW   )Úattribute_ofrM   rN   rY   „  s    z!funccontext_property.<locals>.getc                    s   t | jˆ |ƒ d S rV   )Úsetattrr  )rJ   r‹   )r   rM   rN   rp   †  s    z!funccontext_property.<locals>.set)r`   r   Ú
attrgetterÚproperty)ÚfuncrY   rp   rM   )r  r   rN   Úfunccontext_property  s
    
r  c                   @   s   e Zd Zddd„ZdS )ÚCCodeConfigTc                 C   s   || _ || _|| _d S rV   )Úemit_code_commentsr¯  Úc_line_in_traceback)rJ   r¯  r  r  rM   rM   rN   rO     s    zCCodeConfig.__init__N)TTT)r`   ra   rb   rO   rM   rM   rM   rN   r  ‹  s   r  c                   @   s¾  e Zd ZdZejd d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edd„ ƒZedd„ ƒZedd„ ƒZedd„ ƒZedd „ ƒZed!d"„ ƒZed#d$„ ƒZed%d&„ ƒZdd'd(„Zd)d*„ Zd+d,„ Zd-d.„ Zd/d0„ Zd1d2„ Zd3d4„ Zd5d6„ Zd7d8„ Z d9d:„ Z!d;d<„ Z"dd=d>„Z#d?d@„ Z$dAdB„ Z%dCdD„ Z&ddFdG„Z'dHdI„ Z(dJdK„ Z)ddLdM„Z*dNdO„ Z+dPdQ„ Z,dRdS„ Z-ddTdU„Z.d	dVdW„Z/d
dYdZ„Z0d[d\„ Z1d]d^„ Z2d_d`„ Z3dadb„ Z4dcdd„ Z5dedf„ Z6dgdh„ Z7didj„ Z8dkdl„ Z9dmdn„ Z:dodp„ Z;dqdr„ Z<dsdt„ Z=dudv„ Z>dwdx„ Z?ddydz„Z@d{d|„ ZAd}d~„ ZBdd€„ ZCdd‚„ ZDeEfdƒd„„ZFd…d†„ ZGd‡dˆ„ ZHd‰dŠ„ ZId‹dŒ„ ZJddŽ„ ZKdd„ ZLdd‘d’„ZMdd“d”„ZNd•d–„ ZOd—d˜„ ZPd™dš„ ZQd›dœ„ ZRdddž„ZSdŸd „ ZTdd¡d¢„ZUdd£d¤„ZVdd¥d¦„ZWdd§d¨„ZXd©dª„ ZYd«d¬„ ZZd­d®„ Z[dd¯d°„Z\d±d²„ Z]d³d´„ Z^dµd¶„ Z_dd¸d¹„Z`dºd»„ Zad¼d½„ Zbdd¾d¿„ZcddÀdÁ„ZddÂdÃ„ ZeddÄdÅ„ZfddÇdÈ„ZgddÉdÊ„ZhdËdÌ„ ZiddÍdÎ„ZjddÏdÐ„ZkddÑdÒ„ZlddÓdÔ„ZmdÕdÖ„ Znd×dØ„ ZoddÙdÚ„ZpddÛdÜ„Zqd dÝdÞ„Zrdßdà„ Zsdádâ„ Ztdãdä„ Zudådæ„ Zvdçdè„ Zwdédê„ Zxd!dëdì„Zydídî„ Zzd"dïdð„Z{d#dñdò„Z|dódô„ Z}d$dõdö„Z~d%d÷dø„Zdùdú„ Z€d&dûdü„Zdýdþ„ Z‚dÿd „ Zƒdd„ Z„dS ('  ÚCCodeWritera¦  
    Utility class to output C code.

    When creating an insertion point one must care about the state that is
    kept:
    - formatting state (level, bol) is cloned and used in insertion points
      as well
    - labels, temps, exc_vars: One must construct a scope in which these can
      exist by calling enter_cfunc_scope/exit_cfunc_scope (these are for
      sanity checking and forward compatibility). Created insertion points
      looses this scope and cannot access it.
    - marker: Not copied to insertion point
    - filename_table, filename_list, input_file_contents: All codewriters
      coming from the same root share the same instances simultaneously.
    ©Úcreate_fromNFc                 C   s–   |d u rt ƒ }|| _d | _d | _g | _d | _d | _d | _d| _d| _	d| _
|d ur’|  |j¡ |j| _|r‚|j| _|j
| _
|j	| _	|j| _|j| _d S )Nr   r   )r   ÚbufferÚlast_posÚlast_marked_posZpyclass_stackr  r  rœ  ÚlevelZ
call_levelÚbolr¨  )rJ   r  r   Úcopy_formattingrM   rM   rN   rO   µ  s(    zCCodeWriter.__init__c                 C   s   t |||ƒ}|S rV   ©r  )rJ   r  r   r%  rb  rM   rM   rN   Ú
create_newÐ  s    zCCodeWriter.create_newc                 C   s    | j d u sJ ‚|| _ |j| _d S rV   )r  rœ  )rJ   Zglobal_staterM   rM   rN   r¨  Ö  s    zCCodeWriter.set_global_statec                 C   s   | j  |¡ d S rV   )r   Úcopyto)rJ   rŸ   rM   rM   rN   r(  Û  s    zCCodeWriter.copytoc                 C   s
   | j  ¡ S rV   )r   ÚgetvaluerW   rM   rM   rN   r)  Þ  s    zCCodeWriter.getvaluec                 C   s>   | j r| j d nd}| jj |g| d¡ ¡ | j |¡ d S )Nr   r   rk   )r"  r   ÚmarkersÚextendÚcountr_   )rJ   rÝ   Zcython_linenorM   rM   rN   r_   á  s    zCCodeWriter.writec                 C   s   | j | | j ¡ dd}|S )NT)r  r   r%  )r'  r   rª  rŒ  rM   rM   rN   rª  è  s    zCCodeWriter.insertion_pointc                 C   s
   t | dS )z
        Creates a new CCodeWriter connected to the same global state, which
        can later be inserted using insert.
        r  r&  rW   rM   rM   rN   Ú
new_writerì  s    zCCodeWriter.new_writerc                 C   s"   |j | j u sJ ‚| j |j¡ dS )zË
        Inserts the contents of another code writer (created with
        the same global state) in the current location.

        It is ok to write to the inserted writer also after insertion.
        N)r  r   Úinsert)rJ   r  rM   rM   rN   r.  ó  s    zCCodeWriter.insertc                 C   s   d S rV   rM   rW   rM   rM   rN   r%  þ  s    zCCodeWriter.label_counterc                 C   s   d S rV   rM   rW   rM   rM   rN   r(     s    zCCodeWriter.return_labelc                 C   s   d S rV   rM   rW   rM   rM   rN   r$    s    zCCodeWriter.error_labelc                 C   s   d S rV   rM   rW   rM   rM   rN   r&    s    zCCodeWriter.labels_usedc                 C   s   d S rV   rM   rW   rM   rM   rN   r*    s    zCCodeWriter.continue_labelc                 C   s   d S rV   rM   rW   rM   rM   rN   r+    s    zCCodeWriter.break_labelc                 C   s   d S rV   rM   rW   rM   rM   rN   Úreturn_from_error_cleanup_label
  s    z+CCodeWriter.return_from_error_cleanup_labelc                 C   s   d S rV   rM   rW   rM   rM   rN   r,    s    zCCodeWriter.yield_labelsc                 C   s   | j  |¡S rV   )r  r'  ©rJ   r   rM   rM   rN   r'    r‰   zCCodeWriter.new_labelc                 C   s
   | j  ¡ S rV   )r  r)  rW   rM   rM   rN   r)    r‰   zCCodeWriter.new_error_labelc                 G   s   | j j|Ž S rV   )r  rA  )rJ   rû   rM   rM   rN   rA    r‰   zCCodeWriter.new_yield_labelc                 C   s
   | j  ¡ S rV   )r  rD  rW   rM   rM   rN   rD    r‰   zCCodeWriter.get_loop_labelsc                 C   s   | j  |¡S rV   )r  rG  rE  rM   rM   rN   rG    r‰   zCCodeWriter.set_loop_labelsc                 C   s
   | j  ¡ S rV   )r  rK  rW   rM   rM   rN   rK    r‰   zCCodeWriter.new_loop_labelsc                 C   s
   | j  ¡ S rV   )r  rM  rW   rM   rM   rN   rM    r‰   zCCodeWriter.get_all_labelsc                 C   s   | j  |¡S rV   )r  rN  rE  rM   rM   rN   rN    r‰   zCCodeWriter.set_all_labelsc                 C   s
   | j  ¡ S rV   )r  rQ  rW   rM   rM   rN   rQ    r‰   zCCodeWriter.all_new_labelsc                 C   s   | j  |¡S rV   )r  rT  rR  rM   rM   rN   rT    r‰   zCCodeWriter.use_labelc                 C   s   | j  |¡S rV   )r  rU  rR  rM   rM   rN   rU    r‰   zCCodeWriter.label_usedc                 C   s   t | |d| _d S )N)r#  )r   r  rl  rM   rM   rN   r¬    s    zCCodeWriter.enter_cfunc_scopec                 C   s
   d | _ d S rV   r  rW   rM   rM   rN   r¹     s    zCCodeWriter.exit_cfunc_scopec                 C   s   | j  ||¡jS rV   )r  rÉ  rê   )rJ   rÆ  rÇ  rM   rM   rN   Ú
get_py_int%  s    zCCodeWriter.get_py_intc                 C   s   | j  ||¡jS rV   )r  rË  rê   )rJ   rÆ  rp  rM   rM   rN   Úget_py_float(  s    zCCodeWriter.get_py_floatrƒ   c                 C   s   | j  ||||¡jS rV   ©r  rÐ  rê   )rJ   rC   r¬   rÍ  rÎ  rM   rM   rN   rÐ  +  s    zCCodeWriter.get_py_constc                 C   s   | j  |¡jS rV   )r  rÕ  rê   rÛ  rM   rM   rN   rÕ  .  s    zCCodeWriter.get_string_constc                 C   s   | j  |¡S rV   )r  r×  rÛ  rM   rM   rN   r×  1  s    z#CCodeWriter.get_pyunicode_ptr_constc                 C   s   | j  ||||¡jS rV   )r  rè   rê   )rJ   rx  rç   r‡  rØ  rM   rM   rN   rè   4  s    ÿzCCodeWriter.get_py_string_constc                 C   s   | j  |¡jS rV   r3  )rJ   rC   rM   rM   rN   Úget_argument_default_const9  s    z&CCodeWriter.get_argument_default_constc                 C   s
   |   |¡S rV   rÚ  rÛ  rM   rM   rN   rŠ  <  s    zCCodeWriter.internc                 C   s   | j |ddS rÙ  rÚ  rÛ  rM   rM   rN   Úintern_identifier?  s    zCCodeWriter.intern_identifierc                 C   s   | j  |¡S rV   )r  rÁ  r¿  rM   rM   rN   rÁ  B  s    z'CCodeWriter.get_cached_constants_writerc                 C   sv   | j r| jr|  ¡  | jjrD| jrD| j\}}}|  d|| ¡ f ¡ |rb|rX|  |¡ n
|  	|¡ |  d¡ d| _d S )Nz
#line %s "%s"
rk   r   )
r!  r$  Úemit_markerrœ  r¯  r"  r_   Úget_escaped_descriptionÚput_safer  )rJ   r]   Úsafer  r¡   r7   rM   rM   rN   r\   G  s    

zCCodeWriter.putlnTc                 C   s>   |d u rd S | j r0| j d d… |d d… kr0d S ||f| _d S )Nr   )r"  r!  ©rJ   rï  ÚtracerM   rM   rN   Úmark_posU  s
     zCCodeWriter.mark_posc                 C   s’   | j \}}|| _d | _ |  d¡ | jjrD|  ¡  |  d|  |¡ ¡ |rŽ| jrŽ| jjrŽ| j	j
d rŽ|  ¡  |  d|d | jj |  |¡f ¡ d S )Nrk   z	/* %s */
Z	linetracez__Pyx_TraceLine(%d,%d,%s)
r   )r!  r"  r_   rœ  r  ÚindentÚ_build_markerr  r-  r  r  r.  ró  r:  rM   rM   rN   r6  \  s    

ÿzCCodeWriter.emit_markerc                 C   sv   |\}}}t |tƒsJ ‚| j |¡}|td|d ƒ|… }|d  d7  < ||||d … 7 }d| ¡ |d |¡f S )Nr   rõ   r?   z             # <<<<<<<<<<<<<<r   z"%s":%d
%s
rk   )r×   r   r  r  Úmaxr7  rh   )rJ   rï  r  r¡   ÚcolÚcontentsr{   rM   rM   rN   r>  i  s    
zCCodeWriter._build_markerc                 C   s   |   |¡ d| _d S ©Nr   )r_   r$  ©rJ   r]   rM   rM   rN   r8  r  s    
zCCodeWriter.put_safec                 C   s¸   | j j}|rªt|ƒdkrªd|t | d¡¡ ¡ f }tj 	||¡}tj 
|¡s¢d|t ¡ f }tt |¡ƒ}| |¡ W d   ƒ n1 sŒ0    Y  t ||¡ d| }|  |¡ d S )Ni   z%s_%s.hr  z%s.tmp%sz#include "%s"
)r  r  r»   ÚhashlibÚmd5rv   Ú	hexdigestr   rd   rh   ÚexistsÚgetpidr   r   Úopen_new_filer_   ÚshutilÚmover  )rJ   r]   r   Zinclude_dirZinclude_filerd   Ztmp_pathrŸ   rM   rM   rN   r  w  s    ÿ(zCCodeWriter.put_or_includec                 C   s¼   d}d|v r|  d¡}nd}d|v rp||  d¡8 }|dk rJ|  j|7  _n&|dkrp|d dkrpd}|  jd8  _| jr~|  ¡  |  |¡ d| _|dkr¦|  j|7  _n|r¸|  jd7  _d S )NFÚ{r   r¶  Tr   )r,  r#  r$  r=  r_   )rJ   r]   Z
fix_indentÚdlrM   rM   rN   r  …  s&    
zCCodeWriter.putc                 K   s&   ddl m} |  ||fi |¤Ž¡ d S ©Nr   r  )r  r   r\   ©rJ   r]   rÞ   r   rM   rM   rN   Úputln_tempitaœ  s    zCCodeWriter.putln_tempitac                 K   s&   ddl m} |  ||fi |¤Ž¡ d S rN  )r  r   r  rO  rM   rM   rN   Úput_tempita   s    zCCodeWriter.put_tempitac                 C   s   |  j d7  _ d S ©Nr   ©r#  rW   rM   rM   rN   Úincrease_indent¤  s    zCCodeWriter.increase_indentc                 C   s   |  j d8  _ d S rR  rS  rW   rM   rM   rN   Údecrease_indent§  s    zCCodeWriter.decrease_indentc                 C   s   |   d¡ |  ¡  d S )NrL  )r\   rT  rW   rM   rM   rN   Úbegin_blockª  s    
zCCodeWriter.begin_blockc                 C   s   |   ¡  |  d¡ d S )Nr¶  )rU  r\   rW   rM   rM   rN   Ú	end_block®  s    zCCodeWriter.end_blockc                 C   s   |   d| j ¡ d S )Nz  )r_   r#  rW   rM   rM   rN   r=  ²  s    zCCodeWriter.indentc                 C   s   dt |ƒd d d…  S )Nz0x%02X%02X%02X%02X)r   r   r   r   r  )rå   )rJ   Z	pyversionrM   rM   rN   Úget_py_version_hexµ  s    zCCodeWriter.get_py_version_hexc                 C   s   || j jv r|  d| ¡ d S )Nz%s:;)r  r&  r\   rR  rM   rM   rN   r¸  ¸  s    zCCodeWriter.put_labelc                 C   s   | j  |¡ |  d| ¡ d S )Núgoto %s;)r  rT  r\   rR  rM   rM   rN   Úput_goto¼  s    zCCodeWriter.put_gotoc                 C   sª   |j dkr|s|jsd S |j dkr,|js,d S |r>|  d| ¡ |jsN|  d¡ |  |jj|j|d¡ |jd urŠ|  	d|j 
|j¡ ¡ n|jjrœ|  d¡ |  d¡ d S )NÚprivateú%s úCYTHON_UNUSED )Údll_linkagez = %sz = NULLú;)Z
visibilityZdefined_in_pxdre  r  Zcf_usedrC   rû  rê   rÐ   r8  Zliteral_coderY  r\   )rJ   r½  Zstorage_classr^  Z
definitionrM   rM   rN   Úput_var_declarationÀ  s     

ÿ

zCCodeWriter.put_var_declarationc           	      C   sÎ   |j D ]n\}}}}| |¡}|jr2|  d| ¡ q|jrZddlm} |  d||jf ¡ q|  d|rhdpjd|f ¡ q|jrÊ| j	j
rŠd}nd}|  d	|tjf ¡ |  d
|tjf ¡ |  d	|tjf ¡ d S )Nz
%s = NULL;r   ©Ú
MemoryViewz%s = %s;z%s%s;zstatic rƒ   r]  z%sint %s = 0;z%sconst char *%s = NULL;)r/  rû  rY  r\   rZ  rƒ   rb  Zmemslice_entry_initr6  r  r7  r   Úlineno_cnameÚfilename_cnameÚclineno_cname)	rJ   Zfunc_contextr   rC   r_  r`  rþ  rb  ZunusedrM   rM   rN   Úput_temp_declarationsÕ  s    
z!CCodeWriter.put_temp_declarationsc                 C   s   |   dtj ¡ |   d¡ d S )Nz/* Generated by Cython %s */rƒ   )r\   r   Z	watermarkrW   rM   rM   rN   Úput_generated_byê  s    zCCodeWriter.put_generated_byc                 C   s    |   d| ¡ |   d| ¡ d S )Nz
#ifndef %sz
#define %s©r\   )rJ   ZguardrM   rM   rN   Úput_h_guardî  s    zCCodeWriter.put_h_guardc                 C   s   t jrd| S |S d S )Nzunlikely(%s))r	   Zgcc_branch_hints©rJ   ÚcondrM   rM   rN   Úunlikelyò  s    zCCodeWriter.unlikelyc                    s$   |sdS dd  ‡ fdd„|D ƒ¡ S )Nrƒ   r\  ú c                    s   g | ]}ˆ ||ƒ‘qS rM   rM   )r¨   r¢   ©ÚmapperrM   rN   r«   û  r‰   z8CCodeWriter.build_function_modifiers.<locals>.<listcomp>)rh   )rJ   Ú	modifiersro  rM   rn  rN   Úbuild_function_modifiersø  s    z$CCodeWriter.build_function_modifiersc                 C   s2   |j }|js|j  ¡ r|j jr(d|j S |jS d S )Nz(PyObject *))rC   Zis_self_argZis_completeZis_extension_typerê   )rJ   r½  rC   rM   rM   rN   Úentry_as_pyobjectÿ  s    ÿ
zCCodeWriter.entry_as_pyobjectc                 C   s   ddl m}m} ||||ƒS )Nr   ©Úpy_object_typeÚtypecast)rV  rt  ru  )rJ   rê   rC   rt  ru  rM   rM   rN   Úas_pyobject  s    zCCodeWriter.as_pyobjectc                 C   s   |   d| ¡ d S ©Nz__Pyx_GOTREF(%s);rh  ©rJ   rê   rM   rM   rN   Ú
put_gotref  s    zCCodeWriter.put_gotrefc                 C   s   |   d| ¡ d S ©Nz__Pyx_GIVEREF(%s);rh  rx  rM   rM   rN   Úput_giveref  s    zCCodeWriter.put_giverefc                 C   s   |   d| ¡ d S ©Nz__Pyx_XGIVEREF(%s);rh  rx  rM   rM   rN   Úput_xgiveref  s    zCCodeWriter.put_xgiverefc                 C   s   |   d| ¡ d S ©Nz__Pyx_XGOTREF(%s);rh  rx  rM   rM   rN   Úput_xgotref  s    zCCodeWriter.put_xgotrefc                 C   s6   |r|   d|  ||¡ ¡ n|   d|  ||¡ ¡ d S ©Nz__Pyx_INCREF(%s);zPy_INCREF(%s);)r\   rv  ©rJ   rê   rC   ÚnannyrM   rM   rN   Ú
put_incref  s    zCCodeWriter.put_increfc                 C   s   | j |||ddd d S )NF)Ú
null_checkr•   ©Ú_put_decrefr  rM   rM   rN   Ú
put_decref  s    zCCodeWriter.put_decrefc                 C   s    |j jr|  d|  |¡ ¡ d S rw  ©rC   rY  r\   rr  r¼  rM   rM   rN   Úput_var_gotref   s    zCCodeWriter.put_var_gotrefc                 C   s    |j jr|  d|  |¡ ¡ d S rz  rˆ  r¼  rM   rM   rN   Úput_var_giveref$  s    zCCodeWriter.put_var_giverefc                 C   s    |j jr|  d|  |¡ ¡ d S r~  rˆ  r¼  rM   rM   rN   Úput_var_xgotref(  s    zCCodeWriter.put_var_xgotrefc                 C   s    |j jr|  d|  |¡ ¡ d S r|  rˆ  r¼  rM   rM   rN   Úput_var_xgiveref,  s    zCCodeWriter.put_var_xgiverefc                 C   s:   |j jr6|r"|  d|  |¡ ¡ n|  d|  |¡ ¡ d S r€  rˆ  ©rJ   r½  r‚  rM   rM   rN   Úput_var_incref0  s    zCCodeWriter.put_var_increfc                 C   s    |j jr|  d|  |¡ ¡ d S )Nz__Pyx_XINCREF(%s);rˆ  r¼  rM   rM   rN   Úput_var_xincref7  s    zCCodeWriter.put_var_xincrefc                 C   s   | j |||dd|d d S )NFT©r„  r•   Úclear_before_decrefr…  ©rJ   rê   rC   r‚  r‘  rM   rM   rN   Úput_decref_clear;  s    ÿzCCodeWriter.put_decref_clearc                 C   s   | j |||d|dd d S )NTF)r„  Úhave_gilr•   r…  )rJ   rê   rC   r‚  r”  rM   rM   rN   Úput_xdecref?  s    ÿzCCodeWriter.put_xdecrefc                 C   s   | j |||dd|d d S )NTr  r…  r’  rM   rM   rN   Úput_xdecref_clearC  s    ÿzCCodeWriter.put_xdecref_clearc           
   	   C   s–   |j r| j||d d S |r dnd}|r,dnd}	|rv|rV|s@d}	|  d||	|f ¡ q’|  d||	|  ||¡|f ¡ n|  d||	|  ||¡f ¡ d S )	N)r”  Z__PyxZPyÚXrƒ   z%s_%sCLEAR(%s);z%s_%sDECREF(%s); %s = 0;z%s_%sDECREF(%s);)rZ  Úput_xdecref_memoryviewslicer\   rv  )
rJ   rê   rC   r‚  r„  r”  r•   r‘  r¬   r—  rM   rM   rN   r†  G  s     ÿ
ÿzCCodeWriter._put_decrefc                 C   s   |   d||f ¡ d S )Nz__Pyx_DECREF_SET(%s, %s);rh  ©rJ   rê   Z	rhs_cnamerM   rM   rN   Úput_decref_set\  s    zCCodeWriter.put_decref_setc                 C   s   |   d||f ¡ d S )Nz__Pyx_XDECREF_SET(%s, %s);rh  r™  rM   rM   rN   Úput_xdecref_set_  s    zCCodeWriter.put_xdecref_setc                 C   s    |j jr|  d|  |¡ ¡ d S )Nú__Pyx_XDECREF(%s);rˆ  r¼  rM   rM   rN   Úput_var_decrefb  s    zCCodeWriter.put_var_decrefc                 C   s:   |j jr6|r"|  d|  |¡ ¡ n|  d|  |¡ ¡ d S )Nrœ  zPy_XDECREF(%s);rˆ  r  rM   rM   rN   Úput_var_xdecreff  s    zCCodeWriter.put_var_xdecrefc                 C   s   | j |dd d S )NF©r„  ©Ú_put_var_decref_clearr¼  rM   rM   rN   Úput_var_decref_clearm  s    z CCodeWriter.put_var_decref_clearc                 C   s   | j |dd d S )NTrŸ  r   r¼  rM   rM   rN   Úput_var_xdecref_clearp  s    z!CCodeWriter.put_var_xdecref_clearc                 C   sT   |j jrP|jr,|  d|rdpd|jf ¡ n$|  d|r:dp<d|  |¡|jf ¡ d S )Nz__Pyx_%sCLEAR(%s);r—  rƒ   z__Pyx_%sDECREF(%s); %s = 0;)rC   rY  Ú
in_closurer\   rê   rr  )rJ   r½  r„  rM   rM   rN   r¡  s  s    
þ

ýz!CCodeWriter._put_var_decref_clearr   c                 C   s4   |D ]*}|r|j r|jr$|  |¡ q|  |¡ qd S rV   )re  Zxdecref_cleanuprž  r  )rJ   ÚentriesZ	used_onlyr½  rM   rM   rN   Úput_var_decrefs  s
    
zCCodeWriter.put_var_decrefsc                 C   s   |D ]}|   |¡ qd S rV   )rž  ©rJ   r¥  r½  rM   rM   rN   Úput_var_xdecrefs‰  s    zCCodeWriter.put_var_xdecrefsc                 C   s   |D ]}|   |¡ qd S rV   )r£  r§  rM   rM   rN   Úput_var_xdecrefs_clear  s    z"CCodeWriter.put_var_xdecrefs_clearc                 C   s4   ddl m} | j |j¡ |  d|t|ƒf ¡ d S )Nr   ra  z__PYX_INC_MEMVIEW(&%s, %d);©rƒ   rb  r  r  Zmemviewslice_init_coder\   rÃ  ©rJ   Úslice_cnamer”  rb  rM   rM   rN   Úput_incref_memoryviewslice‘  s    z&CCodeWriter.put_incref_memoryviewslicec                 C   s4   ddl m} | j |j¡ |  d|t|ƒf ¡ d S )Nr   ra  z__PYX_XDEC_MEMVIEW(&%s, %d);rª  r«  rM   rM   rN   r˜  –  s    z'CCodeWriter.put_xdecref_memoryviewslicec                 C   s   |   d| ¡ d S )Nz
%s.memview)r}  )rJ   r¬  rM   rM   rN   Úput_xgiveref_memoryviewslice›  s    z(CCodeWriter.put_xgiveref_memoryviewslicec                 C   sJ   ddl m}m} |||dƒ}|r4|  d||f ¡ n|  d||f ¡ d S )Nr   rs  ÚPy_Nonez%s = %s; __Pyx_INCREF(Py_None);z%s = %s; Py_INCREF(Py_None);)rV  rt  ru  r\   )rJ   rê   rC   r‚  rt  ru  Zpy_nonerM   rM   rN   Úput_init_to_py_nonež  s
    zCCodeWriter.put_init_to_py_noneú%sc                 C   s.   ||j  }|  ||j|¡ |jr*|  d¡ d S )Nr¯  )rê   r°  rC   r¤  r{  )rJ   r½  Útemplater‚  r]   rM   rM   rN   Úput_init_var_to_py_none¦  s    
z#CCodeWriter.put_init_var_to_py_nonec           	      C   sâ   |j s|jdkr:|jtvr:|jdkr2| jjd s2n|r:d S |j ¡ }|sLd S |j rjddlm} ||j	g7 }|rx| 
|¡n|j}d|v rŠdnd}d	|v rž|d
7 }|dkr²d||f }|  d|j|d |¡|jrÒ|jnd|f ¡ d S )NÚ__getattribute__Ú__getattr__Zfast_getattrr   )Ú	TypeSlotsZMETH_FASTCALLZ__Pyx_PyCFunctionFastZPyCFunctionZMETH_KEYWORDSZWithKeywordsz(void*)(%s)%sz!{"%s", (PyCFunction)%s, %s, %s}%sú|r  )Ú
is_specialr   Úspecial_py_methodsr  r  Ú	signatureÚmethod_flagsrƒ   r¶  Zmethod_coexistÚput_pymethoddef_wrapperÚ
func_cnamer\   rh   ÚdocZ	doc_cname)	rJ   r½  ZtermZ
allow_skipZwrapper_code_writerr»  r¶  Zfunc_ptrÚcastrM   rM   rN   Úput_pymethoddef®  s6    

ûÿzCCodeWriter.put_pymethoddefc                 C   sD   |j }|jr@|j ¡ }|r@d|v r@tj| }|  d||j f ¡ |S )NZMETH_NOARGSzSstatic PyObject *%s(PyObject *self, CYTHON_UNUSED PyObject *arg) {return %s(self);})r½  r¸  rº  r»  r   Zmethod_wrapper_prefixr\   )rJ   r½  r½  r»  rM   rM   rN   r¼  Î  s    

ÿz#CCodeWriter.put_pymethoddef_wrapperc                 C   s†   | j  t dd¡¡ | j jd r6| j  t dd¡¡ n| j  t dd¡¡ |  d¡ |sjd}|rj|  d¡ |  d	| ¡ |  d
¡ dS )a  
        Acquire the GIL. The generated code is safe even when no PyThreadState
        has been allocated for this thread (for threads not initialized by
        using the Python API). Additionally, the code generated by this method
        may be called recursively.
        ÚForceInitThreadsúModuleSetupCode.cÚfast_gilÚFastGilÚ	NoFastGilú#ifdef WITH_THREADÚ__pyx_gilstate_savezPyGILState_STATE z%s = __Pyx_PyGILState_Ensure();rê  N)r  r  rÎ   r³   r  r\   r  )rJ   Údeclare_gilstateÚvariablerM   rM   rN   Úput_ensure_gilÛ  s    
ÿ

zCCodeWriter.put_ensure_gilc                 C   sd   | j jd r"| j  t dd¡¡ n| j  t dd¡¡ |s>d}|  d¡ |  d| ¡ |  d¡ d	S )
zD
        Releases the GIL, corresponds to `put_ensure_gil`.
        rÃ  rÄ  rÂ  rÅ  rÇ  rÆ  z__Pyx_PyGILState_Release(%s);rê  N©r  r  r  rÎ   r³   r\   ©rJ   rÉ  rM   rM   rN   Úput_release_ensured_gilð  s    
z#CCodeWriter.put_release_ensured_gilc                 C   st   | j jd r"| j  t dd¡¡ n| j  t dd¡¡ |  d¡ |  d¡ |r\|  d| ¡ |  d¡ |  d	¡ d
S )z
        Acquire the GIL. The thread's thread state must have been initialized
        by a previous `put_release_gil`
        rÃ  rÄ  rÂ  rÅ  rÆ  z__Pyx_FastGIL_Forget();z_save = %s;ZPy_BLOCK_THREADSrê  NrË  rÌ  rM   rM   rN   Úput_acquire_gilþ  s    


zCCodeWriter.put_acquire_gilc                 C   s~   | j jd r"| j  t dd¡¡ n| j  t dd¡¡ |  d¡ |  d¡ |  d¡ |rf|  d| ¡ |  d	¡ |  d
¡ dS )z2Release the GIL, corresponds to `put_acquire_gil`.rÃ  rÄ  rÂ  rÅ  rÆ  zPyThreadState *_save;ZPy_UNBLOCK_THREADSz%s = _save;z__Pyx_FastGIL_Remember();rê  NrË  rÌ  rM   rM   rN   Úput_release_gil	  s    



zCCodeWriter.put_release_gilc                 C   s"   |   d¡ |   d¡ |   d¡ d S )NrÆ  z%PyGILState_STATE __pyx_gilstate_save;rê  rh  rW   rM   rM   rN   rÈ  	  s    

zCCodeWriter.declare_gilstatec                 C   s   |   d||  |¡f ¡S )Nzif (%s < 0) %s)r\   ró  )rJ   rï  r‹   rM   rM   rN   Úput_error_if_neg#	  s    zCCodeWriter.put_error_if_negc              	   C   s„   ddl m} |jr&d}| j |j¡ n2|jjrF|rFd}| j |j¡ nd}| j |j	¡ |  
d|j |j¡||j|  |¡f ¡ d S )Nr   )Ú	ExprNodesZ__Pyx_RaiseClosureNameErrorZ&__Pyx_RaiseUnboundMemoryviewSliceNogilZ__Pyx_RaiseUnboundLocalErrorz#if (unlikely(!%s)) { %s("%s"); %s })rƒ   rÑ  Zfrom_closurer  r  Z%raise_closure_name_error_utility_coderC   rZ  Z+raise_unbound_memoryview_utility_code_nogilZ&raise_unbound_local_error_utility_coder\   Zcheck_for_null_coderê   r   ró  )rJ   rï  r½  Zin_nogil_contextrÑ  r  rM   rM   rN   Úput_error_if_unbound(	  s*    ÿÿÿüz CCodeWriter.put_error_if_unboundc                 C   s.   d| j _|rd| j _d|  |d ¡|d f S )NTz__PYX_MARK_ERR_POS(%s, %s)r   r   )r  r6  r7  r	  )rJ   rï  re  rM   rM   rN   Úset_error_info=	  s    þzCCodeWriter.set_error_infoc                 C   sT   | j j}| j  |¡ |d u r$d| S d| j _|r8d| j _d|  |d ¡|d |f S )NrY  Tz__PYX_ERR(%s, %s, %s)r   r   )r  r$  rT  r6  r7  r	  )rJ   rï  re  rS  rM   rM   rN   ró  E	  s    ýzCCodeWriter.error_gotoc                 C   s   d|   |¡|  |¡f S )Nz
if (%s) %s)rl  ró  )rJ   rk  rï  rM   rM   rN   Úerror_goto_ifR	  s    zCCodeWriter.error_goto_ifc                 C   s   |   d| |¡S )Nz!%s©rÔ  ©rJ   rê   rï  rM   rM   rN   r  U	  s    zCCodeWriter.error_goto_if_nullc                 C   s   |   d| |¡S )Nz%s < 0rÕ  rÖ  rM   rM   rN   Úerror_goto_if_negX	  s    zCCodeWriter.error_goto_if_negc                 C   s   |   d|¡S )NzPyErr_Occurred()rÕ  )rJ   rï  rM   rM   rN   r  [	  s    zCCodeWriter.error_goto_if_PyErrc                 C   s   | j  |¡S rV   )r  r	  )rJ   r›   rM   rM   rN   r	  ^	  s    zCCodeWriter.lookup_filenamec                 C   s   |   d¡ d S )NZ__Pyx_RefNannyDeclarationsrh  rW   rM   rM   rN   r­  a	  s    z(CCodeWriter.put_declare_refcount_contextc                 C   s6   |r| j  t dd¡¡ |  d||r(dp*df ¡ d S )NrÁ  rÂ  z%__Pyx_RefNannySetupContext("%s", %d);r   r   )r  r  rÎ   r³   r\   )rJ   r   Zacquire_gilrM   rM   rN   r®  d	  s
    
ÿz&CCodeWriter.put_setup_refcount_contextc                 C   s   |   d¡ d S )Nz__Pyx_RefNannyFinishContext();rh  rW   rM   rM   rN   rº  j	  s    z'CCodeWriter.put_finish_refcount_contextc                 C   s4   ||rt jndt jt jf}d| j_|  d| ¡ dS )zŒ
        Build a Python traceback for propagating exceptions.

        qualified_name should be the qualified name of the function.
        r   Tz%__Pyx_AddTraceback("%s", %s, %s, %s);N)r   re  rc  rd  r  r7  r\   )rJ   Úqualified_nameZinclude_clineÚformat_tuplerM   rM   rN   Úput_add_tracebackm	  s    üzCCodeWriter.put_add_tracebackc                 C   sL   |t jt jt j| jjd |f}d| j_|  d| ¡ | j 	t
 dd¡¡ dS )zœ
        Generate code to print a Python warning for an unraisable exception.

        qualified_name should be the qualified name of the function.
        Zunraisable_tracebacksTz0__Pyx_WriteUnraisable("%s", %s, %s, %s, %d, %d);ZWriteUnraisableExceptionzExceptions.cN)r   re  rc  rd  r  r  r  r7  r\   r  rÎ   r³   )rJ   rØ  ÚnogilrÙ  rM   rM   rN   Úput_unraisable|	  s    
ú
ÿzCCodeWriter.put_unraisablec                 C   s   |   d¡ d S )NZ__Pyx_TraceDeclarationsrh  rW   rM   rM   rN   Úput_trace_declarations	  s    z"CCodeWriter.put_trace_declarationsc                 C   s   |r|   d| ¡ d S )Nz__Pyx_TraceFrameInit(%s)rh  )rJ   ÚcodeobjrM   rM   rN   Úput_trace_frame_init’	  s    z CCodeWriter.put_trace_frame_initc                 C   s4   |   d|tj|  |d ¡|d ||  |¡f ¡ d S )Nz*__Pyx_TraceCall("%s", %s[%s], %s, %d, %s);r   r   )r\   r   Zfiletable_cnamer	  ró  )rJ   r   rï  rÛ  rM   rM   rN   Úput_trace_call–	  s    "ÿzCCodeWriter.put_trace_callc                 C   s   |   d¡ d S )Nz__Pyx_TraceException();rh  rW   rM   rM   rN   Úput_trace_exceptionš	  s    zCCodeWriter.put_trace_exceptionc                 C   s   |   d||f ¡ d S )Nz__Pyx_TraceReturn(%s, %d);rh  )rJ   Zretvalue_cnamerÛ  rM   rM   rN   Úput_trace_return	  s    zCCodeWriter.put_trace_returnc                 C   s"   |   d¡ |   |¡ |   d¡ d S )Nz#ifdef _OPENMPz#endif /* _OPENMP */rh  )rJ   ÚstringrM   rM   rN   Úputln_openmp 	  s    

zCCodeWriter.putln_openmpc                 C   sD   |   d| ¡ |   d¡ |   d¡ |   d¡ |   d¡ |   d¡ dS )zl
        Redefine the macros likely() and unlikely to no-ops, depending on
        condition 'cond'
        rè  ú    #undef likelyú    #undef unlikelyz    #define likely(x)   (x)z    #define unlikely(x) (x)rê  Nrh  rj  rM   rM   rN   Úundef_builtin_expect¥	  s    



z CCodeWriter.undef_builtin_expectc                 C   sD   |   d| ¡ |   d¡ |   d¡ |   d¡ |   d¡ |   d¡ d S )Nrè  rå  ræ  z2    #define likely(x)   __builtin_expect(!!(x), 1)z2    #define unlikely(x) __builtin_expect(!!(x), 0)rê  rh  rj  rM   rM   rN   Úredef_builtin_expect±	  s    



z CCodeWriter.redef_builtin_expect)NNF)N)N)rƒ   NN)NFN)N)rƒ   F)T)rƒ   NT)T)T)T)TF)TT)TF)TFTFF)T)r   )F)F)T)r±  T)TN)TN)N)N)N)F)F)T)F)T)F)N)F)F)…r`   ra   rb   rc   ÚcythonÚlocalsrO   r'  r¨  r(  r)  r_   rª  r-  r.  r  r%  r(  r$  r&  r*  r+  r/  r,  r'  r)  rA  rD  rG  rK  rM  rN  rQ  rT  rU  r¬  r¹  r1  r2  rÐ  rÕ  r×  rè   r4  rŠ  r5  rÁ  r\   r<  r6  r>  r8  r  r  rP  rQ  rT  rU  rV  rW  r=  rX  r¸  rZ  r`  rf  rg  ri  rl  Úmodifier_output_mapperrq  rr  rv  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­  r˜  r®  r°  r³  rÀ  r¼  rÊ  rÍ  rÎ  rÏ  rÈ  rÐ  rÒ  rÓ  ró  rÔ  r  r×  r  r	  r­  r®  rº  rÚ  rÜ  rÝ  rß  rà  rá  râ  rä  rç  rè  rM   rM   rM   rN   r  –  s  








 ÿ
	 ÿ
 ÿ
 
r  c                   @   s,   e Zd Zdd„ Zdd„ Zdd„ Zdd„ Zd	S )
ÚPyrexCodeWriterc                 C   s   t  |¡| _d| _d S rB  )r   rI  rŸ   r#  )rJ   Zoutfile_namerM   rM   rN   rO   ¾	  s    zPyrexCodeWriter.__init__c                 C   s   | j  dd| j |f ¡ d S )Nú%s%s
rm  )rŸ   r_   r#  rC  rM   rM   rN   r\   Â	  s    zPyrexCodeWriter.putlnc                 C   s   |  j d7  _ d S rR  rS  rW   rM   rM   rN   r=  Å	  s    zPyrexCodeWriter.indentc                 C   s   |  j d8  _ d S rR  rS  rW   rM   rM   rN   ÚdedentÈ	  s    zPyrexCodeWriter.dedentN)r`   ra   rb   rO   r\   r=  rî  rM   rM   rM   rN   rì  º	  s   rì  c                   @   sj   e Zd ZdZddd„Zddd	„Zdd
d„Zdd„ Zdd„ Zddd„Z	dd„ Z
ddd„Zdd„ Zdd„ ZdS )ÚPyxCodeWriterzÂ
    Can be used for writing out some Cython code. To use the indenter
    functionality, the Cython.Compiler.Importer module will have to be used
    to load the code to support python 2.4
    Nr   r5   c                 C   s"   |pt ƒ | _|| _|| _|| _d S rV   )r   r   r#  rÞ   r‡   )rJ   r   Úindent_levelrÞ   r‡   rM   rM   rN   rO   Ò	  s    zPyxCodeWriter.__init__r   c                 C   s   |  j |7  _ dS )NTrS  ©rJ   ZlevelsrM   rM   rN   r=  Ø	  s    zPyxCodeWriter.indentc                 C   s   |  j |8  _ d S rV   rS  rñ  rM   rM   rN   rî  Ü	  s    zPyxCodeWriter.dedentc                 C   s   |   |¡ |  ¡  dS )a  
        Instead of

            with pyx_code.indenter("for i in range(10):"):
                pyx_code.putln("print i")

        write

            if pyx_code.indenter("for i in range(10);"):
                pyx_code.putln("print i")
                pyx_code.dedent()
        T)r\   r=  ©rJ   r¡   rM   rM   rN   Úindenterß	  s    
zPyxCodeWriter.indenterc                 C   s$   | j  ¡ }t|tƒr | | j¡}|S rV   )r   r)  r×   r   rà  r‡   )rJ   rb  rM   rM   rN   r)  ð	  s    

zPyxCodeWriter.getvaluec                 C   s&   |p| j }|rt||ƒ}|  |¡ d S rV   )rÞ   r  Ú_putln)rJ   r¡   rÞ   rM   rM   rN   r\   ö	  s    

zPyxCodeWriter.putlnc                 C   s   | j  d| jd |f ¡ d S )Nrí  z    )r   r_   r#  rò  rM   rM   rN   rô  ü	  s    zPyxCodeWriter._putlnc                 C   s>   |p| j }|rt||ƒ}t |¡}| ¡ D ]}|  |¡ q*d S rV   )rÞ   r  r   rî  r  rô  )rJ   ÚchunkrÞ   r¡   rM   rM   rN   Ú	put_chunkÿ	  s    


zPyxCodeWriter.put_chunkc                 C   s   t | j ¡ | j| jƒS rV   )rï  r   rª  r#  rÞ   rW   rM   rM   rN   rª  
  s    ÿzPyxCodeWriter.insertion_pointc                 C   s   t | ||  ¡ ƒ d S rV   )r  rª  r0  rM   rM   rN   Únamed_insertion_point
  s    z#PyxCodeWriter.named_insertion_point)Nr   Nr5   )r   )r   )N)N)r`   ra   rb   rc   rO   r=  rî  ró  r)  r\   rô  rö  rª  r÷  rM   rM   rM   rN   rï  Ë	  s   




	rï  c                   @   s$   e Zd Zdd„ Zdd„ Zdd„ ZdS )rk  c                 C   s   || _ i | _i | _d| _d S rB  )Úklassr/  r0  Útemps_count)rJ   rø  rM   rM   rN   rO   
  s    zClosureTempAllocator.__init__c                 C   s&   | j  ¡ D ]\}}t|ƒ| j|< q
d S rV   )r/  rw   r½   r0  )rJ   rC   rÿ  rM   rM   rN   Úreset
  s    zClosureTempAllocator.resetc                 C   s‚   || j vr g | j |< g | j|< n| j| r:| j|  d¡S dtj| jf }| jjd |||dd | j |  |¡ |  jd7  _|S )Nr   r=  T)rï  r   rê   rC   Zis_cdefr   )	r/  r0  r[  r   r]  rù  rø  Zdeclare_varr˜   )rJ   rC   rê   rM   rM   rN   rc  
  s    


z"ClosureTempAllocator.allocate_tempN)r`   ra   rb   rO   rú  rc  rM   rM   rM   rN   rk  
  s   rk  )NN)LÚ
__future__r   ré  ZdeclareÚobjectr   r   rJ  Úsysr   r   rã  r   Ú	functoolsr   Ú
contextlibr   Úcollectionsr   rD  ÚImportErrorrE  rƒ   r   r	   r   r
   r   r   ZScanningr   r   Ú__builtin__r   Úbuiltinsr   Úversion_inforu   rí  Zctypedef_builtins_mapZbasicsize_builtins_mapZuncachable_builtinsrp   r¹  rY   rë  r=   ri   rj   rÎ   r  r  r  r   rn  rr  rŽ   rà  ÚUr‘   rs  rv   rt  r   ru  Úfindallrv  rw  r†  rŽ  r  r  r  rì  rï  rk  rM   rM   rM   rN   Ú<module>   s¶   ü
úùþ'ÿL q 9
  ÿO    D
      *E