Your IP : 216.73.216.213
Z��Z�n � * @ s d d l m Z d d l Z e j d e d e d e d e d e d e d e d
e d e d e d
e d e d e d e d e d e � 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 y d d l Z Wn e k
r>d d l Z Yn Xd 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 y d d! l m! Z! Wn" e k
r�d d" l" m# Z! Yn Xe j$ d d# f k Z% d$ d% d& f d' d( d& f d d( d& f d) d( d* f d+ d( d, f i Z& d- d. i Z' d/ d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 d: d; d< d= d> d? d@ dA dB dC dD dE dF dG dH g Z( e) dI dJ dK dL dM dN dO dP dQ dR dS dT dU g
� Z* dV dW i j+ Z, e j- dX � j. Z/ GdY dZ � dZ e � Z0 d[ d\ � Z1 Gd] d^ � d^ e � Z2 Gd_ d` � d` e2 � Z3 d d da db � Z4 Gdc dd � dd e3 � Z5 Gde df � df e2 � Z6 Gdg dh � dh e � Z7 Gdi dj � dj e � Z8 Gdk dl � dl e � Z9 e j dm e dn e do e dp e � e j- dq j: dE � e j; � j. Z< e j- dr j= ds � � j. Z> e j- dt � j? Z@ e j- du � jA ZB Gdv dw � dw e � ZC Gdx dy � dy e � ZD Gdz d{ � d{ e � ZE d| d} � ZF Gd~ d � d e � ZG Gd� d� � d� e � ZH Gd� d� � d� e � ZI Gd� d� � d� e � ZJ Gd� d� � d� e � ZK d 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� �byteszPY_MAJOR_VERSION < 3r �unicodezPY_MAJOR_VERSION >= 3�xrange�rangeZ raw_input�inputZ PyTypeObjectZPyHeapTypeObjectZ
breakpoint�
__loader__�__spec__�BlockingIOError�BrokenPipeError�ChildProcessError�ConnectionAbortedError�ConnectionError�ConnectionRefusedError�ConnectionResetError�FileExistsError�FileNotFoundError�InterruptedError�IsADirectoryErrorZModuleNotFoundError�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_INLINEz *(\w+) = (\1);\s*$c @ sv e Z d Z d Z d Z d Z d Z d Z d d d 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 | _ | r� | d d k ro | d d k ro d j | � | j d <d } n d j | � | j d <| r� | | 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�includeZverbatimZlate�initial� rI �G/opt/alt/python35/lib64/python3.5/site-packages/Cython/Compiler/Code.py�__init__� s zIncludeCode.__init__c C sR | | k rD | | } t | j | 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)�minrC r@ �update)rF �d�key�otherrI rI rJ � dict_update� s
zIncludeCode.dict_updatec C s | j S)N)r> )rF rI rI rJ �sortkey� s zIncludeCode.sortkeyc C s | j 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 )r@ �get)rF rI rI rJ � mainpiece� s zIncludeCode.mainpiecec C s2 x+ t | j � D] } | j | j | � q Wd S)N)�sortedr@ �putln)rF �code�krI rI rJ �write� s zIncludeCode.write)
�__name__�
__module__� __qualname__�__doc__rB rE rD r= rK rQ rR rT rY rI rI rI rJ r9 s s r9 c C s= t j j t j j t j j t � � � } t j j | d � S)NZUtility)r �path�dirname�abspath�__file__�join)Z
Cython_dirrI rI rJ �get_utility_dir� s *rc 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 d
d � � Z
e d d d
� � Z e j
d � j d d � Z d d � Z 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 k r d Sd j | � } | r� d | k r� | d t d g � k r� | d =y t | � j t t � � } WnD t t f k
r� } z t d | | | f � � WYd d } ~ Xn Xd | | } | d k r� | | d <nB | d k r� | | d <n) | d } t r| j
d
� } | | | <| r~| d } xK | j � D]= \ } }
t r^| j
d
� } | j | t � � j
|
� q=Wd S) N�
�
substituteZnamingz@Error parsing templated utility code of type '%s' at line %d: %s�protor �implr r �ASCII)rb �setr rf �varsr �KeyError�
ValueError� RuntimeError�KEYWORDS_MUST_BE_BYTES�encode�items�
setdefaultrM ) �cls�utilityr? �lines� begin_lineno�tagsrW �eZall_tags�name�valuesrI rI rJ � _add_utility� s2 + &
z UtilityCodeBase._add_utilityc C s� | j j | � } | r | St j j t � | � } t j j | � \ } } | d k r� d } t t j d � j
d � } t j j
} n< d } t t j d � j
d � } t t j d
� j
d � } t j d d
| i � j } t j d � j }
t t j | d d �� � } | j � } Wd QRXt d d � � } g }
t t � } d } } d } x
t | � D]� \ } } | | � } | rG| j d � r| j | | |
| | � | d } |
d d � =| j � | j d � } |
| � } | r| j � \ } } n d } | | } q`| | j d � j | j d � � |
j d � qd|
j | | | � � � qdW| d k r|t d � � | j | | |
| | � t | � } | | j | <| S)N�.pyx�.py�.pxd�.pxi�#z^\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)$�encodingzUTF-8c S s
d d i g S)NrI rI rI rI rJ �<lambda>! s z:UtilityCodeBase.load_utilities_from_file.<locals>.<lambda>r ry r rh �tag�valuezEmpty utility code file)r| r} r~ r ) �_utility_cacherS r r^ rb rc �splitextr r �compile�subr
Z_unicode�rstrip�matchr r Zopen_source_file� readlinesr rj � enumerate�groupr{ �clear�groups�add�appendrm �dict)rs r^ � utilities�filenamer3 �ext�comment�strip_commentsr� Z
match_specialZ
match_type�fZ all_linesru rw rt r? rv �lineno�line�mry �mtyperI rI rJ �load_utilities_from_file s\
#
z(UtilityCodeBase.load_utilities_from_filec s~ d | k r$ | j d d � \ � } � s t � � | d � y t j � � } Wnn t k
r� d d l } t } | j � t | j � � � �) } � � f d d � | j
� D� } Wd QRXYn X� f d d � | D� } | s� t d | � � t | � d k rt d
| � � | d � � j
� � } | | \ }
} } | r| j � � x� | j � D]� \ }
} |
| k rxq]|
d k r�� r�� � � f d d � t | � D� } q� � f d
d � t | � D� } n1 | s�d } n" t | � d k rt | � d } | | |
<q]W|
d k r,|
| d <| d k rB| | d <d | k rX| | d <d | k rt� rt� | d <� | � 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 | ]6 } t j j � | � j � � r t j j | � � q SrI )r r^ rb �
startswith�basename)�.0ry )�archive� utility_dirrI rJ �
<listcomp>_ s z(UtilityCodeBase.load.<locals>.<listcomp>c s% g | ] } | j � � r | � q SrI )r� )r� r� )�prefixrI rJ r� b s z No match found for utility code z4More than one filename match found for utility code �requiresc s% g | ] } � j | � � � � q SrI )�load)r� �dep)rs � from_file� orig_kwargsrI rJ r� u s c s" g | ] } � j | � � � q SrI )� load_cached)r� r� )rs r� rI rJ r� y s rg rh ry �file)�rsplitrc r �listdir�OSError�zipfiler r� r �ZipFile�namelistrm �lenr� �copyrq rU �list)rs �util_code_namer� �kwargsZlistingr� �loader�fileobj�filesr� rg rh rw ry rz rI )r� rs r� r� r� r� rJ r� H s^
zUtilityCodeBase.loadc C sN | | | f } y | | SWn t k
r/ Yn X| j | | � } | | <| S)z`
Calls .load(), but using a per-type cache based on utility name and file name.
)rl r� )rs �utility_code_namer� Z_UtilityCodeBase__cacherO rW rI rI rJ r� � s
zUtilityCodeBase.load_cachedc K sD | j | | | � } | j | j } } | j | � | j | � f S)zR
Load a utility code as a string. Returns (proto, implementation)
)r� rg rh � format_code)rs r� r� r� �utilrg rh rI rI rJ �load_as_string� s z UtilityCodeBase.load_as_stringz\n\n+c C s# | r | d | j � � d } | S)z3
Format a code section for output.
re z
)�strip)rF Z code_stringZreplace_empty_linesrI rI rJ r� � s zUtilityCodeBase.format_codec C s d t | � j | j f S)Nz<%s(%s)>)r? rZ ry )rF rI rI rJ �__str__� s zUtilityCodeBase.__str__c K s d S)NrI )rF r� rI rI rJ �get_tree� s zUtilityCodeBase.get_tree)rZ r[ r\ r] Zis_cython_utilityr� � classmethodr{ r� r� r� r� r r� r� r� r� r� rI rI rI rJ rd � s !@D rd c
@ s� e Z d Z d Z d d d d d d d 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)N)
rg rh �init�cleanupr� �_cache�specialize_list� proto_blockry r� ) rF rg rh r� r� r� r� ry r� rI rI rJ rK � s zUtilityCode.__init__c C s t | j | j f � S)N)�hashrg rh )rF rI rI rJ �__hash__� s zUtilityCode.__hash__c C s� | | k r d St | � t | � } } | | k rX t | | � pP t | | � rX d St | d d � } t | d d � } | | j f | | j f k S)NTFrg )r? �
isinstance�getattrrh )rF rP Z self_typeZ
other_typeZ
self_protoZ other_protorI rI rJ �__eq__� s +zUtilityCode.__eq__c C s | d k r d S| | S)zY
Format a string in this utility code with context. If None, do nothing.
NrI )rF �s�contextrI rI rJ � none_or_sub� s zUtilityCode.none_or_subc
s | d k r, | j � � d <| j � � d <t t � j � � � } y | j | SWn� t k
r| j d k r{ d } n � f d d � | j D� } t | j | j
� � | j | j � � | j | j � � | j | j
� � | | j � } | j | <| j j | � | SYn Xd S)Nr? Z type_namec s g | ] } | j � � � q SrI )�
specialize)r� �r)�datarI rJ r� � s z*UtilityCode.specialize.<locals>.<listcomp>)Zempty_declaration_codeZspecialization_name�tuplerU rq r� rl r� r� r� rg rh r� r� r� r� r� )rF Z
pyrex_typer� rO r� r� rI )r� rJ r� � s&
zUtilityCode.specializec s� d | k r" d | k r" d | f Si � � � f d d � } t j d | | � } d | k rj d | k sp t � t � � | f S)zHReplace 'PYIDENT("xyz")' by a constant Python identifier cname.
zPYIDENT(z
PYUNICODE(Fc sn | j � } y � | } WnM t k
ri | \ } } � j t j | � d | d k �j } � | <Yn X| S)N�
identifierZIDENT)r� rl �get_py_string_constr
�
EncodedString�cname)�matchobjrO r� Zstr_typery )�output� replacementsrI rJ � externalise s
.z8UtilityCode.inject_string_constants.<locals>.externalisez PY(IDENT|UNICODE)\("([^"]+)"\))r r� �AssertionError�bool)rF rh r� r� rI )r� r� rJ �inject_string_constants s
z#UtilityCode.inject_string_constantsc s� d | k r d | f St � } � f d d � } t j d | | � } d | k sX t � x- t | � D] } � j t j | d � � qe Wt | � | f S)zVReplace 'UNBOUND_METHOD(type, "name")' by a constant Python identifier cname.
zCALL_UNBOUND_METHOD(Fc s� | j � \ } } } } | rD d d � | d d � j d � D� n g } t | � d k sr t d t | � � � � j | | | | � S)Nc S s g | ] } | j � � q SrI )r� )r� �argrI rI rJ r� s zKUtilityCode.inject_unbound_methods.<locals>.externalise.<locals>.<listcomp>r �,� z8CALL_UNBOUND_METHOD() does not support %d call arguments)r� �splitr� r� � cached_unbound_method_call_code)r� �
type_cname� method_name� obj_cname�args)r� rI rJ r� s 2(z7UtilityCode.inject_unbound_methods.<locals>.externalisezMCALL_UNBOUND_METHOD\(([a-zA-Z_]+),\s*"([^"]+)",\s*([^),]+)((?:,\s*[^),]+)*)\)zObjectHandling.c) rj r r� r� rU �use_utility_coder� r� r� )rF rh r� � utility_coder� �helperrI )r� rJ �inject_unbound_methods s
z"UtilityCode.inject_unbound_methodsc C sG d | k r | Sd d � } t j d | | � } d | k sC t � | S)z<Replace CSTRING('''xyz''') by a C compatible string
zCSTRING(c S s; | j d � j d d � } d j d d � | j � D� � S)Nr �"r� c s sL | ]B } | j d � s( | j d � r2 d | n d | d d � Vq d S)�\z\\z"%s\n"
z"%s"
Nr r< )�endswith)r� r� rI rI rJ � <genexpr>: s zCUtilityCode.wrap_c_strings.<locals>.split_string.<locals>.<genexpr>)r� �replacerb �
splitlines)r� �contentrI rI rJ � split_string7 s z0UtilityCode.wrap_c_strings.<locals>.split_stringz)CSTRING\(\s*"""([^"]*(?:"[^"]+)*)"""\s*\))r r� r� )rF rh r� rI rI rJ �wrap_c_strings1 s zUtilityCode.wrap_c_stringsc C s& | j r* x | j D] } | j | � q W| j rw | | j } | j d | j � | j | j | j � d | j � | j r | j | j | j � � } | j
| | � \ } } | j | | � \ } } | d } | j d | j � | p� | s| j | d | j � n
| j | � | j
r�| d } | j d | j � t | j
t � rq| j | j | j
� � n | j
| | j � | j | j | j � � | j � | j r"t j r"| d } | j d | j � t | j t � r| j | j | j � d
| j � n | j | | 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� r� rg r� rV ry �put_or_includer� rh r� r� r� �putr� r� r �
module_pos�error_goto_if_PyErrr� r �generate_cleanup_code)rF r� Z
dependency�writerrh Zis_specialised1Zis_specialised2rI rI rJ �put_codeA sB
zUtilityCode.put_code)
rZ r[ r\ r] rK r� r� r� r� r� r� r� r rI rI rI rJ r� � s
r� c C sT | s
d S| r' d | | f | d <n | r7 | | d <d d l m } | | | � S)z+Run tempita on string s with given context.Nz%s:%sZ__namer )r� )�Tempitar� )r� r� r� ry r� rI rI rJ � sub_tempitai s
r c s[ e Z d Z d d d d d d � f d d � Z e d d i d d � � Z d d � Z � S)�TempitaUtilityCodeNc
s� | d k r i } t | | | | � } t | | | | � } t | | | | � } t t | � j | | d | d | d | | �d S)Nr� ry r� )r �superr rK )rF ry rg rh r� r� r� r� )� __class__rI rJ rK x s zTempitaUtilityCode.__init__c
C s� | r t t | j � � � n d } t | � d k s< t � | | | | f } y | | SWn t k
rn Yn X| j | | d | �} | | <| S)Nr� )r� rU rq r� r� rl r� )rs r� r� r� Z_TempitaUtilityCode__cacheZ context_keyrO rW rI rI rJ r� � s $
z TempitaUtilityCode.load_cachedc C s) | d k r d St | | | j | j � S)zY
Format a string in this utility code with context. If None, do nothing.
N)r r� ry )rF r� r� rI rI rJ r� � s z TempitaUtilityCode.none_or_sub)rZ r[ r\ rK r� r� r� rI rI )r rJ r w 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)N)�callback)rF r
rI rI rJ rK � s zLazyUtilityCode.__init__c C s# | j | j � } | j | � d S)N)r
�
rootwriterr� )rF � globalstatert rI rI rJ r � s zLazyUtilityCode.put_code)rZ r[ r\ r] r� rK r rI rI rI rJ r � s
r c @ s e Z d Z e � d d d � Z d 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 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).�
FunctionStateNc C s� | | _ | | _ | | _ d | _ d | _ t � | _ | j � | _ | j � d | _
d | _ g | _ d | _
d | _ d | _ d | _ d | _ g | _ i | _ i | _ d | _ d | _ g | _ d | _ d | _ d S)Nr FT)� names_taken�owner�scope� error_label�
label_counterrj � labels_used� new_label� return_label�new_error_label�continue_label� break_label� yield_labelsZin_try_finallyZexc_varsZcurrent_except� can_trace� gil_owned�temps_allocated�
temps_free�temps_used_type� temp_counter�
closure_temps�collect_temps_stack� should_declare_error_indicator�uses_error_indicator)rF r r r rI rI rJ rK � s0
zFunctionState.__init__c C sG | j } | d | _ d t j | f } | d k rC | d | 7} | S)Nr z%s%dr3 )r r Z label_prefix)rF ry �n�labelrI rI rJ r � s
zFunctionState.new_label�yieldc C s@ | j d | � } t | j � d | f } | j j | � | S)Nzresume_from_%sr )r r� r r� )rF Z expr_typer% Z
num_and_labelrI rI rJ �new_yield_label� s z FunctionState.new_yield_labelc C s | j } | j d � | _ | S)N�error)r r )rF Z old_err_lblrI rI rJ r � s z FunctionState.new_error_labelc C s | j | j f S)N)r r )rF rI rI rJ �get_loop_labels� s z FunctionState.get_loop_labelsc C s | \ | _ | _ d S)N)r r )rF �labelsrI rI rJ �set_loop_labels� s z FunctionState.set_loop_labelsc C s5 | j � } | j | j d � | j d � f � | S)N�continue�break)r) r+ r )rF �
old_labelsrI rI rJ �new_loop_labels� s
z FunctionState.new_loop_labelsc C s | j | j | j | j f S)N)r r r r )rF rI rI rJ �get_all_labels� s z FunctionState.get_all_labelsc C s" | \ | _ | _ | _ | _ d S)N)r r r r )rF r* rI rI rJ �set_all_labels s z FunctionState.set_all_labelsc C s{ | j � } g } xU t | d d d d g � D]8 \ } } | rY | j | j | � � q. | j | � q. W| j | � | S)Nr, r- �returnr( )r0 �zipr� r r1 )rF r. Z
new_labelsZ old_labelry rI rI rJ �all_new_labels
s (
z FunctionState.all_new_labelsc C s | j j | � d S)N)r r� )rF �lblrI rI rJ � use_label s zFunctionState.use_labelc C s
| | j k S)N)r )rF r5 rI rI rJ �
label_used s zFunctionState.label_usedFc C s\ | j r | j r | j } n | j r; | j r; | j } | j rU | j rU d } | j j | | f � } | d k r� | d r� | d j � } | d j
| � nX x9 | j d 7_ d t j
| j f } | | j k r� Pq� W| j j | | | | f � | | f | j | <t j r5| j j d | | f � | j rX| j d j | | 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.
A C string referring to the variable is returned.
FNr r z%s%dz/* %s allocated (%s) */r< )�is_constZ is_referenceZconst_base_typeZis_fake_referenceZ
ref_base_type� is_pyobject�is_memoryviewslicer rS �pop�remover r �codewriter_temp_prefixr r r� r r �debug_temp_code_commentsr rV r! r� )rF r? �
manage_ref�static�freelist�resultrI rI rJ �
allocate_temp s, zFunctionState.allocate_tempc C s� | j | \ } } | j j | | f � } | d k rY g t � f } | | j | | f <| | d k ry t d | � � | d j | � | d j | � t j r� | j j
d | � d S)zv
Releases a temporary so that it can be reused by other code needing
a temp of the same type.
Nr zTemp %s freed twice!r z/* %s released */) r r rS rj rn r� r� r r> r rV )rF ry r? r? rA rI rI rJ � release_tempN s zFunctionState.release_tempc C s} g } xp | j D]e \ } } } } | j j | | f � } | d k sV | | d k r | j | | | on | j f � q W| S)zxReturn a list of (cname,type,manage_ref) tuples of temp names and their type
that are currently in use.
Nr )r r rS r� r9 )rF �usedry r? r? r@ rA rI rI rJ � temps_in_use_ s #zFunctionState.temps_in_usec C s d d � | j � 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 s4 g | ]* \ } } } | r | j r | | f � q SrI )r9 )r� ry r? r? rI rI rJ r� o s z9FunctionState.temps_holding_reference.<locals>.<listcomp>)rF )rF rI rI rJ �temps_holding_referencej 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 SrI rI )r� r� r? r? r@ rI rI rJ r� v s z3FunctionState.all_managed_temps.<locals>.<listcomp>)r )rF rI rI rJ �all_managed_tempss s z FunctionState.all_managed_tempsc C s d d � | j 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 | ]5 \ \ } } } | r | d D] } | | f � q& q S)r rI )r� r? r? rA r� rI rI rJ r� � s z8FunctionState.all_free_managed_temps.<locals>.<listcomp>)r rq )rF rI rI rJ �all_free_managed_tempsz s z$FunctionState.all_free_managed_tempsc C s | j j t � � d S)zJ
Useful to find out which temps were used in a code block
N)r! r� rj )rF rI rI rJ �start_collecting_temps� s z$FunctionState.start_collecting_tempsc C s
| j j � S)N)r! r; )rF rI rI rJ �stop_collecting_temps� s z#FunctionState.stop_collecting_tempsc C s t | � | _ d S)N)�ClosureTempAllocatorr )rF r rI rI rJ �init_closure_temps� s z FunctionState.init_closure_temps)rZ r[ r\ rj rK r r' r r) r+ r/ r0 r1 r4 r6 r7 rC rD rF rG rH rI rJ rK rM rI rI rI rJ r
� s*
' 1
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)N)r� r� �py_type�
value_code)rF r� r� rO rP rI rI rJ rK � s zNumConst.__init__)rZ r[ r\ r] rK rI rI rI rJ 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)N)r� r? )rF r� r? rI rI rJ rK � s zPyObjectConst.__init__N)rZ r[ r\ r] rK rI rI rI rJ rQ � s rQ �possible_unicode_identifier�possible_bytes_identifier�replace_identifier�find_alphanumss
(?![0-9])\w+$z
(?![0-9])\w+$ri z[^a-zA-Z0-9_]+z([a-zA-Z0-9]+)c @ sC e Z d Z d Z d d � Z d d � Z d d d d d � Z d S)
� StringConstz?Global info about a C string constant held by GlobalState.
c C s: | | _ | | _ t j | � | _ d | _ g | _ d S)N)r� �textr
Zescape_byte_string�
escaped_value�
py_strings� py_versions)rF r� rW � byte_stringrI rI rJ rK � s
zStringConst.__init__c C s; | s d d g | _ n | | j k r7 | j j | � d S)Nr r� )rZ r� )rF �versionrI rI rJ �add_py_version� s zStringConst.add_py_versionNFc C s� | j } | j } t | p | � } | d k o4 | } | d k rL d } n< | j � } | d k rs d } d } n d j t | � � } | | | | f } | d k r� y | | SWq� t k
r� Yq� Xn i | _ | r� d }
nK | d k r't | t � rt t | � � }
q-t t
| � � }
n d }
|
rCt j d } n t j
} | r_d
| } n d } d | | rwd p�| r�d
p�d | | j t t j � d � f }
t |
| | | | |
� } | | j | <| S)N�utf8�utf-8r1 �usascii�us-asciir� TFr z_%sz %s%s%s_%sr� �u�b)r^ r_ r1 r` ra )rY rW r� �lowerrb rU rl r� r rS rR r �interned_prefixesZpy_const_prefixr� r� � const_prefix�
PyStringConst)rF r� r� �is_str�py3str_cstringrY rW �
is_unicodeZ encoding_keyrO �internr� Zencoding_prefixZpystring_cname� py_stringrI rI rJ r� � sP
z StringConst.get_py_string_const)rZ r[ r\ r] rK r] r� rI rI rI rJ rV � s
rV c @ s7 e Z d Z d Z d d d d d � Z d d � Z d S)rg zDGlobal info about a Python string constant held by GlobalState.
FNc C s: | | _ | | _ | | _ | | _ | | _ | | _ d S)N)r� ri r� rh rj rk )rF r� r� rj rh ri rk rI rI rJ rK s zPyStringConst.__init__c C s | j | j k S)N)r� )rF rP rI rI rJ �__lt__ s zPyStringConst.__lt__)rZ r[ r\ r] rK rm rI rI rI rJ rg s rg c @ s# e Z d Z i Z d d d d d d d d d d
d d d
d d d d d d d d d d d d 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* d+ � Z d, d- � Z
d. d d/ d0 � Z d d1 d2 � Z d3 d4 � Z d d) d d5 d6 � Z d7 d8 � Z d9 d: � Z d d; d< � Z d. d= d> � Z d? d@ � Z dA dB � Z d. d. dC dD � Z dE dF � Z dG dH � Z dI dJ � Z dK dL � Z dM dN � Z dO dP � Z dQ dR � Z dS dT � Z dU dV � Z! dW dX � Z" dY dZ � Z# d[ d\ � Z$ d] d^ � Z% d_ d` � Z& d S)a� GlobalStateZh_code�filename_tableZ utility_code_proto_before_typesZnumeric_typedefsZcomplex_type_declarationsZtype_declarationsr� Zmodule_declarationsZtypeinfoZbefore_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 | _ g | _ i | _ | j | � | | _ d S)NF)ro �
filename_list�input_file_contentsrj �
utility_codes�declared_cnamesZin_utility_code_generation� code_config�common_utility_include_dir�parts� module_node�const_cnames_used�string_const_index�pyunicode_ptr_const_index�num_const_index� py_constants�cached_cmethods�set_global_stater )rF r r r| r} rI rI rJ rK U s$
zGlobalState.__init__c C s� | j } x$ | j D] } | j � | j | <q Wt j sF | j d =n$ | j d } | j � | j d � | j d } | j � | j d � | j d � | j � | j d � | j d } | j � | j d � | j d � t j
s� | j d =n1 | j d } | j � | j d � | j d
� | j d } | j d � | j d � | j d
} | j j rw| j
d � | j d � | j d � d S)Nrt z+static int __Pyx_InitCachedBuiltins(void) {ru r� z,static int __Pyx_InitCachedConstants(void) {Z__Pyx_InitCachedConstantsr� z$static int __Pyx_InitGlobals(void) {r� z(static 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_scoperV � put_declare_refcount_context�put_setup_refcount_contextr r| �
emit_linenumsrY )rF r �part�wrW rI rI rJ �initialize_main_c_codel s@
z"GlobalState.initialize_main_c_codec C sS | j � | j d } t j d d � } | j | j | j � � | j d � d S)Nr� ZTypeConversionszTypeConversion.cr� )�close_global_declsr~ r r� r� r� rh rV )rF rW r� rI rI rJ �finalize_main_c_code� s
z GlobalState.finalize_main_c_codec C s | j | S)N)r~ )rF rO rI rI rJ � __getitem__� s zGlobalState.__getitem__c C s� | j � t j rs | j d } | j d � | j | j � r\ | j | j � | j d � | j d � | j � | j d } | j � | j d � | j | j � r� | j | j � | j � | j d � | j d � | j � | j d } | j d � | j | j � r0| j | j � | j d � | j d � | j � t j
rt| j d } | j d � | j � t j
r�| j d } | j d � | j � d S) Nrt z return 0;z
return -1;�}ru r� r� rv ) �generate_const_declarationsr r� r~ rV r7 r � put_label�exit_cfunc_scope�put_finish_refcount_contextr )rF r� rI rI rJ r� � sB
z GlobalState.close_global_declsc C s | d j d | j � d S)Nrp zstatic PyObject *%s;)rV r� )rF �entryrI rI rJ �put_pyobject_decl� s z GlobalState.put_pyobject_declc C s | j d S)Nru )r~ )rF rI rI rJ �get_cached_constants_writer� s z'GlobalState.get_cached_constants_writerFc C sT | r d p d } y | j | | f } Wn$ t k
rO | j | | � } Yn X| S)N�long�int)r� rl �
new_num_const)rF � str_value�longnessrO �crI rI rJ �
get_int_const� s
zGlobalState.get_int_constc C sE y | j | d f } Wn' t k
r@ | j | d | � } Yn X| S)N�float)r� rl r� )rF r� rP r� rI rI rJ �get_float_const� s
zGlobalState.get_float_constr� c C sR | j | | � } | d k rN | t j k rN | j d } | j d | j � | S)Nr� z
Py_CLEAR(%s);)� new_py_constr r r~ rV r� )rF r? r� �
cleanup_level�constZcleanup_writerrI rI rJ � get_py_const� s
zGlobalState.get_py_constc C sm | j r | j � } n | j � } y | j | } Wn$ t k
r[ | j | | � } Yn X| j | � | S)N)rj �
utf8encode�
byteencoder� rl �new_string_constr] )rF rW �
py_versionr[ r� rI rI rJ �get_string_const� s
z GlobalState.get_string_constc C sP | j s t � y | j | } Wn) t k
rK | j � } | j | <Yn X| S)N)rj r� r� rl �new_const_cname)rF rW r� rI rI rJ �get_pyunicode_ptr_const� s
z#GlobalState.get_pyunicode_ptr_constc C s� d } | r] | d k r] | j � | j � k r] | j | d d �} | j | d d �} n | j | � } | j | j | | | � } | S)Nr� r� r )r� r� r� r� r� )rF rW r� rh �
unicode_valueri Zc_stringrl rI rI rJ r� s z GlobalState.get_py_string_constc C s | j | d d �S)Nr� T)r� )rF rW rI rI rJ �get_interned_identifier s z#GlobalState.get_interned_identifierc C s2 | j | � } t | | | � } | | j | <| S)N)�new_string_const_cnamerV r� )rF rW r[ r� r� rI rI rJ r� s
z GlobalState.new_string_constc C s> | j | | � } t | | | | � } | | j | | f <| S)N)�new_num_const_cnamerN r� )rF r� rO rP r� r� rI rI rJ r� s zGlobalState.new_num_constc C s2 | j | � } t | | � } | j j | � | S)N)r� rQ r� r� )rF r? r� r� r� rI rI rJ r� # s zGlobalState.new_py_constc C s" | j d d � } | j d | � S)Nri �ignorer� )�decoder� )rF Z bytes_valuer� rI rI rJ r� ) s z"GlobalState.new_string_const_cnamec C sg | d k r | d 7} d } t j | } d | | f } | j d d � j d d � j d d � } | S)
Nr� �Lr� z%s%s�+r3 �-Zneg_r� )r re r� )rF r� rO r� r� rI rI rJ r� . s
*z GlobalState.new_num_const_cnamec C s� t d | � d d � j d � } | j } | } x6 | | k ri | | d } | | <d | | f } q4 Wd | | <| r� t j | } n t j } d | | f S)Nr3 � r z%s_%dz%s%s)rT r� r� r re rf )rF r� r� rE Z name_suffixr= rI rI rJ r� 7 s "
zGlobalState.new_const_cnamec C s] | | f } y | j | } Wn9 t k
rX | j d d | | f � } | j | <Yn X| S)NZumethodz%s_%s)r� rl r� )rF r� r� rO r� rI rI rJ �get_cached_unbound_methodE s
&z%GlobalState.get_cached_unbound_methodc C sb d t | � } | j t j | d � � | j | | � } | g | } d | | d j | � f S)NzCallUnboundCMethod%dzObjectHandling.cz__Pyx_%s(&%s, %s)z, )r� r� r� r� r� rb )rF r� r� r� Z
arg_cnamesr� Z cache_cnamer� rI rI rJ r� N s
z+GlobalState.cached_unbound_method_call_codec C s� | j r� | j r� | j | j | � r� | j | � | j d } d } | j t k r� t | j \ } } | j d | � | j | j
t j | � | j � | j d � | j | j
t j | j � | j � | r� | j d � d S)Nrt z#if %sz#elsez#endif)
�
is_builtinr8 �should_declarer� r� r~ ry �non_portable_builtins_maprV �put_cached_builtin_init�posr
r� )rF r� r� Z condition� replacementrI rI rJ �add_cached_builtin_declZ s"
z#GlobalState.add_cached_builtin_declc C sb | j d } | j | � j } | j t j d d � � | j d | | | | j | � f � d S)Nrt ZGetBuiltinNamezObjectHandling.cz*%s = __Pyx_GetBuiltinName(%s); if (!%s) %s)r~ r� r� r� r� r� rV �
error_goto)rF r� ry r� r� Zinterned_cnamerI rI rJ r� m s
z#GlobalState.put_cached_builtin_initc C s, | j � | j � | j � | j � d S)N)� generate_cached_methods_decls�generate_string_constants�generate_num_constants� generate_object_constant_decls)rF rI rI rJ r� x s
z'GlobalState.generate_const_declarationsc C sh d d � | j D� } | j � | j d } x4 | D], \ } } } | j d | j j | � � q4 Wd S)Nc S s+ g | ]! } t | j � | j | f � q SrI )r� r� )r� r� rI rI rJ r� s z>GlobalState.generate_object_constant_decls.<locals>.<listcomp>rr z
static %s;)r� �sortr~ rV r? �declaration_code)rF �consts� decls_writerr3 r� r� rI rI rJ r� ~ s
z*GlobalState.generate_object_constant_declsc C s� | j s
d S| j d } | j d } g } x t | j j � � D]h \ \ } } } | j | � | j t j | � � j } | j d | | f � | j d | | f � qC Wt
j r� | j d } x | D] } | j d | � q� Wd S)Nrr r� z4static __Pyx_CachedCFunction %s = {0, &%s, 0, 0, 0};z%s.type = (PyObject*)&%s;r� zPy_CLEAR(%s.method);) r� r~ rU rq r� r� r
r� r� rV r r ) rF �declr� �cnamesr� r� r� Zmethod_name_cnamer� rI rI rJ r� � s
(
z)GlobalState.generate_cached_methods_declsc
C s� d d � | j j � D� } | j � g } | j d } x� | D]� \ } } } d } | j r� d | j k s| d | j k r� d } | j d d | j k r� d p� d
� | j d | t j | j � f � | r� | j d � | j d k r@ x9 | j j � D]( } | j
| j t | j � | f � q� Wq@ Wx� t
| j j � � D]� \ } } t j | � \ } }
| rw| j d
� | j d | |
f � | rC| j d � | j d | | f � | j d � qCW| r}| j t j d d � � | j � | j d } | j d � | j d t j � x
| D]\ } } } | j sY| j sY| j d% k rbd }
n d | j j � }
| j d | j � | j r�| j d � | j d | j | j j | j j d d d | j f � | j d � | j d | j | | |
| j | j | j f � | j r'| j d � q'W| j d! � | j d" � | j d# } | j d$ t j | j | j � f � d S)&Nc S s+ g | ]! } t | j � | j | f � q SrI )r� r� )r� r� rI rI rJ r� � s z9GlobalState.generate_string_constants.<locals>.<listcomp>rq Fr r� Tz#if PY_MAJOR_VERSION %s 3r: z>=z static const char %s[] = "%s";z#endifz#ifdef Py_UNICODE_WIDEz static Py_UNICODE %s[] = { %s };z#elseZ InitStringsz
StringTools.crs r� z$static __Pyx_StringTabEntry %s[] = {ri �USASCII�US-ASCII�UTF8�UTF-8�0z"%s"zstatic PyObject *%s;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;)ri r� r� r� r� ) r� rz r� r~ rZ rV r
Zsplit_string_literalrX rY r� r� r� rU r� rq Zencode_pyunicode_stringr� r� r� r Zstringtab_cnamerh r� rd ri rk rj r� r� )rF Zc_constsrY r� r3 r� r� Z conditionalrl Z utf16_arrayZ utf32_arrayr� Zc_cnamer� r� rI rI rJ r� � s�
'
*"
z%GlobalState.generate_string_constantsc C s d d � | j j � D� } | j � | j d } | j d } x� | D]� \ } } } } } } | j } | j d | � | d k r� d }
nW | d k r� d }
nB t j | � r� d
}
n* t | j d � � d k r� d
}
n d }
| j d | |
| | j
| | j � f � qG Wd S)Nc S sG g | ]= } | j | j d d k t | j � | j | j | f � q S)r r� )rO r� r� rP )r� r� rI rI rJ r� � s z6GlobalState.generate_num_constants.<locals>.<listcomp>rr r� zstatic PyObject *%s;r� zPyFloat_FromDouble(%s)r� z%PyLong_FromString((char *)"%s", 0, 0)z$PyInt_FromString((char *)"%s", 0, 0)r� � zPyInt_FromLong(%sL)zPyInt_FromLong(%s)z %s = %s; %s) r� rz r� r~ r� rV r Z long_literalr� �lstrip�error_goto_if_nullr� ) rF r� r� r� rO r3 r� rP r� r� �functionrI rI rJ r� � s(
z"GlobalState.generate_num_constantsc C sq | | j k r\ | j | } t | j � t | j � k s@ t � | j | j k sX t � d S| | j | <d Sd S)NFT)r{ r r? r� r� )rF r� r� rP rI rI rJ r� s
$
zGlobalState.should_declarec C sb | j � } y | j | } Wn> t k
r] t | j � } | j j | � | | j | <Yn X| S)N)Zget_filenametable_entryro rl r� rx r� )rF � source_descr� �indexrI rI rJ �lookup_filename s
zGlobalState.lookup_filenamec C s� y | j | SWn t k
r# Yn X| j d d d d � } z d d � | D� } Wd t | d � ro | j � X| s� | j d � | | j | <| S) Nr� ri Zerror_handlingr� c S s8 g | ]. } d | j � j d d � j 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� r� rI rI rJ r� % s z7GlobalState.commented_file_contents.<locals>.<listcomp>�closer� )ry rl � get_lines�hasattrr� r� )rF r� � source_file�FrI rI rJ �commented_file_contents s
z#GlobalState.commented_file_contentsc C s6 | r2 | | j k r2 | j j | � | 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)rz r� r )rF r� rI rI rJ r� 6 s z GlobalState.use_utility_codec C sF | d k r d S| j r) | j | j � | j rB | j | j � d S)N)r� r� Zutility_code_definition)rF r� rI rI rJ �use_entry_utility_codeC s z"GlobalState.use_entry_utility_code)'rZ r[ r\ �
directivesr� rK 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� rI rI rI rJ rn sz * )
M
rn c s@ t j � � � � f d d � } � f d d � } t | | � S)Nc s
� | j � S)N)� funcstate)rF )� attribute_ofrI rJ rS N s z!funccontext_property.<locals>.getc s t | j � | � d S)N)�setattrr� )rF r� )ry rI rJ rj P s z!funccontext_property.<locals>.set)r �
attrgetter�property)ry rS rj rI )r� ry rJ �funccontext_propertyL s r� c @ s% e Z d Z d d d d d � Z d S)� CCodeConfigTc C s | | _ | | _ | | _ d S)N)�emit_code_commentsr� �c_line_in_traceback)rF r� r� r� rI rI rJ rK Z s zCCodeConfig.__init__N)rZ r[ r\ rK rI rI rI rJ r� U s r� c @ s� e Z d Z d Z d Z Z 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 � Z e d � Z e d � Z e d � Z e d � Z e d � Z e d � Z e 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 d0 d1 � Z! d2 d3 � Z" d d4 d5 � Z# d6 d7 � Z$ d8 d9 � Z% d: d; � Z& d< d d= d> � Z' d? d@ � Z( dA dB � Z) d d d dC dD � Z* dE dF � Z+ dG dH � Z, dI dJ � Z- dK dL � Z. d< d dM dN � Z/ dO dP dQ � Z0 dR dS � Z1 dT dU � Z2 dV dW � Z3 dX dY � Z4 dZ d[ � Z5 d\ d] � Z6 d^ d_ � Z7 d` da � Z8 db dc � Z9 dd de � Z: df dg � Z; dh di � Z< dj dk � Z= dl dm � Z> dn do � Z? d< d dO dp dq � Z@ dr ds � ZA dt du � ZB dv dw � ZC dx dy � ZD eE dz d{ � ZF d| d} � ZG d~ d � ZH d� d� � ZI d� d� � ZJ d� d� � ZK d� d� � ZL dO d� d� � ZM dO d� d� � ZN d� d� � ZO d� d� � ZP d� d� � ZQ d� d� � ZR dO d� d� � ZS d� d� � ZT dO d d� d� � ZU dO dO d� d� � ZV dO d d� d� � ZW dO d dO d d d� d� � ZX d� d� � ZY d� d� � ZZ d� d� � Z[ dO d� d� � Z\ d� d� � Z] d� d� � Z^ d� d� � Z_ d� d� d� � Z` d� d� � Za d� d� � Zb d d� d� � Zc d d� d� � Zd d� d� � Ze dO d� d� � Zf d� dO d� d� � Zg dO d� d� � Zh dO d d� d� � Zi d d� d� � Zj d d� d� � Zk d d� d� � Zl d� d� � Zm d� d� � Zn d d� d� � Zo d d� d� � Zp d� d� � Zq d� d� � Zr d� d� � Zs d� d� � Zt d� d� � Zu d� d� � Zv d� d� � Zw d d� d� � Zx d� d� � Zy dO d� d� � Zz d d� d� � Z{ d� d� � Z| d d� d� � Z} d d� d� � Z~ d� d� � Z d d� d� � Z� d� 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.
NFc C s� | d k r t � } | | _ d | _ d | _ g | _ d | _ d | _ d | _ d | _ | d k r� | j | j
� | j | _ | r� | j | _ | j | _ | j | _ | j | _ | j | _ d S)Nr r ) r
�buffer�last_pos�last_marked_posZ
pyclass_stackr� �levelZ
call_level�bolr� r )rF � create_fromr� �copy_formattingrI rI rJ rK � s& zCCodeWriter.__init__c C s t | | | � } | S)N)r� )rF r� r� r� rB rI rI rJ �
create_new� s zCCodeWriter.create_newc C s. | j d k s t � | | _ | j | _ d S)N)r r� r| )rF Z global_staterI rI rJ r� � s z CCodeWriter.set_global_statec C s | j j | � d S)N)r� �copyto)rF r� rI rI rJ r� � s zCCodeWriter.copytoc C s
| j j � S)N)r� �getvalue)rF rI rI rJ r� � s zCCodeWriter.getvaluec C sS | j r | j d n d } | j j j | g | j d � � | j j | � d S)Nr r re )r� r� �markers�extend�countrY )rF r� Z
cython_linenorI rI rJ rY � s #zCCodeWriter.writec C s+ | j d | d | j j � d d � } | S)Nr� r� r� T)r� r� r� )rF rP rI rI rJ r� � s 'zCCodeWriter.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� )rF rI rI rJ �
new_writer� s zCCodeWriter.new_writerc C s/ | j | j k s t � | 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� r� �insert)rF r rI rI rJ r� � s zCCodeWriter.insertr r r r r r � return_from_error_cleanup_labelr c C s | j j | � S)N)r� r )rF ry rI rI rJ r � s zCCodeWriter.new_labelc C s
| j j � S)N)r� r )rF rI rI rJ r � s zCCodeWriter.new_error_labelc G s | j j | � S)N)r� r' )rF r� rI rI rJ r' � s zCCodeWriter.new_yield_labelc C s
| j j � S)N)r� r) )rF rI rI rJ r) � s zCCodeWriter.get_loop_labelsc C s | j j | � S)N)r� r+ )rF r* rI rI rJ r+ � s zCCodeWriter.set_loop_labelsc C s
| j j � S)N)r� r/ )rF rI rI rJ r/ � s zCCodeWriter.new_loop_labelsc C s
| j j � S)N)r� r0 )rF rI rI rJ r0 � s zCCodeWriter.get_all_labelsc C s | j j | � S)N)r� r1 )rF r* rI rI rJ r1 � s zCCodeWriter.set_all_labelsc C s
| j j � S)N)r� r4 )rF rI rI rJ r4 � s zCCodeWriter.all_new_labelsc C s | j j | � S)N)r� r6 )rF r5 rI rI rJ r6 � s zCCodeWriter.use_labelc C s | j j | � S)N)r� r7 )rF r5 rI rI rJ r7 � s zCCodeWriter.label_usedc C s t | d | �| _ d S)Nr )r
r� )rF r rI rI rJ r� � s z CCodeWriter.enter_cfunc_scopec C s
d | _ d S)N)r� )rF rI rI rJ r� � s z CCodeWriter.exit_cfunc_scopec C s | j j | | � j S)N)r r� r� )rF r� r� rI rI rJ �
get_py_int� s zCCodeWriter.get_py_intc C s | j j | | � j S)N)r r� r� )rF r� rP rI rI rJ � get_py_float� s zCCodeWriter.get_py_floatr� c C s | j j | | | � j S)N)r r� r� )rF r? r� r� rI rI rJ r� � s zCCodeWriter.get_py_constc C s | j j | � j S)N)r r� r� )rF rW rI rI rJ r� � s z CCodeWriter.get_string_constc C s | j j | � S)N)r r� )rF rW rI rI rJ r� � s z#CCodeWriter.get_pyunicode_ptr_constc C s | j j | | | | � j S)N)r r� r� )rF rW r� rh r� rI rI rJ r� � s z CCodeWriter.get_py_string_constc C s | j j | � j S)N)r r� r� )rF r? rI rI rJ �get_argument_default_const� s z&CCodeWriter.get_argument_default_constc C s
| j | � S)N)r� )rF rW rI rI rJ rk � s zCCodeWriter.internc C s | j | d d �S)Nr� T)r� )rF rW rI rI rJ �intern_identifier s z CCodeWriter.intern_identifierc C s
| j j � S)N)r r� )rF rI rI rJ r� s z'CCodeWriter.get_cached_constants_writerc C s� | j r | j r | j � | j j r` | j r` | j \ } } } | j d | | j � f � | r� | r| | j | � n
| j | � | j d � d | _ d S)Nz
#line %s "%s"
re r )
r� r� � emit_markerr| r� r� rY �get_escaped_description�put_safer� )rF rW �safer� r� r3 rI rI rJ rV s
zCCodeWriter.putlnTc C sS | d k r d S| j r@ | j d d � | d d � k r@ d S| | f | _ d S)Nr )r� r� )rF r� �tracerI rI rJ �mark_pos s
,zCCodeWriter.mark_posc C s� | j \ } } | | _ d | _ | j d � | j j r^ | j � | j d | j | � � | r� | j r� | j j r� | j j
d r� | j � | j d | d | j j | j | � f � d S)Nre z /* %s */
� linetracez__Pyx_TraceLine(%d,%d,%s)
r )
r� r� rY r| r� �indent�
_build_markerr� r r r� r r� )rF r� r rI rI rJ r� s
+
zCCodeWriter.emit_markerc C s� | \ } } } t | t � s$ t � | j j | � } | t d | d � | � } | d d 7<| | | | d � 7} d | j � | d j | � f S) Nr r� r z # <<<<<<<<<<<<<<r z "%s":%d
%s
re r< )r� r r� r r� �maxr rb )rF r� r� r� �col�contentsru rI rI rJ r * s zCCodeWriter._build_markerc C s | j | � d | _ d S)Nr )rY r� )rF rW rI rI rJ r 3 s
zCCodeWriter.put_safec
C s� | j j } | r� t | � d k r� d | t j | j d � � j � f } t j j | | � } t j j
| � s� d | t j � f } t t
j | � � � } | j | � Wd QRXt j | | � d | } | j | � d S)Ni z%s_%s.hr^ z%s.tmp%sz#include "%s"
)r r} r� �hashlib�md5rp � hexdigestr r^ rb �exists�getpidr r �
open_new_filerY �shutil�mover� )rF rW ry Z include_dirZ include_filer^ Ztmp_pathr� rI rI rJ r� 8 s %
zCCodeWriter.put_or_includec C s t | � r d Sd } d | k r4 | j d � } n d } d | k r� | | j d � 8} | d k rw | j | 7_ n1 | d k r� | d d k r� d } | j d 8_ | j r� | j � | j | � d | _ | d k r� | j | 7_ n | r| j d 7_ d S)NF�{r r� Tr )�is_self_assignmentr� r� r� r rY )rF rW Z
fix_indentZdlrI rI rJ r� F s*
zCCodeWriter.putc K s* d d l m } | j | | | � � d S)Nr )r� )r r� rV )rF rW r� r� rI rI rJ �
putln_tempita_ s zCCodeWriter.putln_tempitac K s* d d l m } | j | | | � � d S)Nr )r� )r r� r� )rF rW r� r� rI rI rJ � put_tempitac s zCCodeWriter.put_tempitac C s | j d 7_ d S)Nr )r� )rF rI rI rJ �increase_indentg s zCCodeWriter.increase_indentc C s | j d 8_ d S)Nr )r� )rF rI rI rJ �decrease_indentj s zCCodeWriter.decrease_indentc C s | j d � | j � d S)Nr )rV r )rF rI rI rJ � begin_blockm s
zCCodeWriter.begin_blockc C s | j � | j d � d S)Nr� )r rV )rF rI rI rJ � end_blockq s
zCCodeWriter.end_blockc C s | j d | j � d S)Nz )rY r� )rF rI rI rJ r u s zCCodeWriter.indentc C s d t | � d d d � S)Nz0x%02X%02X%02X%02Xr r� )r r r r )r� )rF Z pyversionrI rI rJ �get_py_version_hexx s z CCodeWriter.get_py_version_hexc C s' | | j j k r# | j d | � d S)Nz%s:;)r� r rV )rF r5 rI rI rJ r� { s zCCodeWriter.put_labelc C s% | j j | � | j d | � d S)Nzgoto %s;)r� r6 rV )rF r5 rI rI rJ �put_goto s zCCodeWriter.put_gotoc C s� | j d k r# | p | j r# d S| j d k r@ | j r@ d S| rW | j d | � | j sm | j d � | j | j j | j d | �� | j d k r� | j d | j j
| j � � n | j j r� | j d � | j d � d S)NZprivatez%s zCYTHON_UNUSED � dll_linkagez = %sz = NULL�;)
Z
visibilityZdefined_in_pxdrE r� Zcf_usedr? r� r� r� r Z literal_coder9 rV )rF r� Z
storage_classr Z
definitionrI rI rJ �put_var_declaration� s
#
z CCodeWriter.put_var_declarationc C s x� | j D]� \ } } } } | j | � } | j rH | j d | � q
| j r~ d d l m } | j d | | j f � q
| j d | r� d p� d | f � q
W| j r| j j
r� d } n d } | j d | t j f � | j d
| t j
f � | j d | t j f � d S) Nz
%s = NULL;r )�
MemoryViewz%s = %s;z%s%s;zstatic r� zCYTHON_UNUSED z
%sint %s = 0;z%sconst char *%s = NULL;)r r� r9 rV r: r� r Zmemslice_entry_initr" r� r# r � lineno_cname�filename_cname�
clineno_cname) rF Z func_contextry r? r? r@ r� r ZunusedrI rI rJ �put_temp_declarations� s ' z!CCodeWriter.put_temp_declarationsc C s% | j d t j � | j d � d S)Nz /* Generated by Cython %s */r� )rV r Z watermark)rF rI rI rJ �put_generated_by� s z CCodeWriter.put_generated_byc C s& | j d | � | j d | � d S)Nz
#ifndef %sz
#define %s)rV )rF ZguardrI rI rJ � put_h_guard� s zCCodeWriter.put_h_guardc C s t j r d | S| Sd S)Nz unlikely(%s))r Zgcc_branch_hints)rF �condrI rI rJ �unlikely� s zCCodeWriter.unlikelyc s. | s
d Sd d j � f d d � | D� � S)Nr� z%s � c s g | ] } � | | � � q SrI rI )r� r� )�mapperrI rJ r� � s z8CCodeWriter.build_function_modifiers.<locals>.<listcomp>)rb )rF � modifiersr* rI )r* rJ �build_function_modifiers� s z$CCodeWriter.build_function_modifiersc C sE | j } | j r# | j j � s/ | j j r: d | j S| j Sd S)Nz (PyObject *))r? Z is_self_argZ is_completeZis_extension_typer� )rF r� r? rI rI rJ �entry_as_pyobject� s
z CCodeWriter.entry_as_pyobjectc C s& d d l m } m } | | | | � S)Nr )�py_object_type�typecast)�
PyrexTypesr. r/ )rF r� r? r. r/ rI rI rJ � as_pyobject� s zCCodeWriter.as_pyobjectc C s | j d | � d S)Nz__Pyx_GOTREF(%s);)rV )rF r� rI rI rJ �
put_gotref� s zCCodeWriter.put_gotrefc C s | j d | � d S)Nz__Pyx_GIVEREF(%s);)rV )rF r� rI rI rJ � put_giveref� s zCCodeWriter.put_giverefc C s | j d | � d S)Nz__Pyx_XGIVEREF(%s);)rV )rF r� rI rI rJ � put_xgiveref� s zCCodeWriter.put_xgiverefc C s | j d | � d S)Nz__Pyx_XGOTREF(%s);)rV )rF r� rI rI rJ � put_xgotref� s zCCodeWriter.put_xgotrefc C sG | r& | j d | j | | � � n | j d | j | | � � d S)Nz__Pyx_INCREF(%s);zPy_INCREF(%s);)rV r1 )rF r� r? �nannyrI rI rJ �
put_incref� s zCCodeWriter.put_increfc C s# | j | | | d d d d �d S)N�
null_checkFr� )� _put_decref)rF r� r? r6 rI rI rJ �
put_decref� s zCCodeWriter.put_decrefc C s* | j j r& | j d | j | � � d S)Nz__Pyx_GOTREF(%s);)r? r9 rV r- )rF r� rI rI rJ �put_var_gotref� s zCCodeWriter.put_var_gotrefc C s* | j j r& | j d | j | � � d S)Nz__Pyx_GIVEREF(%s);)r? r9 rV r- )rF r� rI rI rJ �put_var_giveref� s zCCodeWriter.put_var_giverefc C s* | j j r& | j d | j | � � d S)Nz__Pyx_XGOTREF(%s);)r? r9 rV r- )rF r� rI rI rJ �put_var_xgotref� s zCCodeWriter.put_var_xgotrefc C s* | j j r& | j d | j | � � d S)Nz__Pyx_XGIVEREF(%s);)r? r9 rV r- )rF r� rI rI rJ �put_var_xgiveref� s z CCodeWriter.put_var_xgiverefc C sM | j j rI | r/ | j d | j | � � n | j d | j | � � d S)Nz__Pyx_INCREF(%s);zPy_INCREF(%s);)r? r9 rV r- )rF r� r6 rI rI rJ �put_var_incref� s zCCodeWriter.put_var_increfc C s* | j j r& | j d | j | � � d S)Nz__Pyx_XINCREF(%s);)r? r9 rV r- )rF r� rI rI rJ �put_var_xincref� s zCCodeWriter.put_var_xincrefc
C s) | j | | | d d d d d | �d S)Nr8 Fr� T�clear_before_decref)r9 )rF r� r? r6 rA rI rI rJ �put_decref_clear� s z CCodeWriter.put_decref_clearc
C s) | j | | | d d d | d d �d S)Nr8 T�have_gilr� F)r9 )rF r� r? r6 rC rI rI rJ � put_xdecref s zCCodeWriter.put_xdecrefc
C s) | j | | | d d d d d | �d S)Nr8 Tr� rA )r9 )rF r� r? r6 rA rI rI rJ �put_xdecref_clear s z CCodeWriter.put_xdecref_clearc
C s� | j r | j | d | �d S| r, d n d } | r> d n d } | r� | ry | s\ d } | j d | | | f � q� | j d | | | j | | � | f � n& | j d | | | j | | � f � d S) NrC Z__PyxZPy�Xr� z%s_%sCLEAR(%s);z%s_%sDECREF(%s); %s = 0;z%s_%sDECREF(%s);)r: �put_xdecref_memoryviewslicerV r1 )
rF r� r? r6 r8 rC r� rA r� rF rI rI rJ r9
s # zCCodeWriter._put_decrefc C s | j d | | f � d S)Nz__Pyx_DECREF_SET(%s, %s);)rV )rF r� � rhs_cnamerI rI rJ �put_decref_set s zCCodeWriter.put_decref_setc C s | j d | | f � d S)Nz__Pyx_XDECREF_SET(%s, %s);)rV )rF r� rH rI rI rJ �put_xdecref_set" s zCCodeWriter.put_xdecref_setc C s* | j j r& | j d | j | � � d S)Nz__Pyx_XDECREF(%s);)r? r9 rV r- )rF r� rI rI rJ �put_var_decref% s zCCodeWriter.put_var_decrefc C sM | j j rI | r/ | j d | j | � � n | j d | j | � � d S)Nz__Pyx_XDECREF(%s);zPy_XDECREF(%s);)r? r9 rV r- )rF r� r6 rI rI rJ �put_var_xdecref) s zCCodeWriter.put_var_xdecrefc C s | j | d d �d S)Nr8 F)�_put_var_decref_clear)rF r� rI rI rJ �put_var_decref_clear0 s z CCodeWriter.put_var_decref_clearc C s | j | d d �d S)Nr8 T)rM )rF r� rI rI rJ �put_var_xdecref_clear3 s z!CCodeWriter.put_var_xdecref_clearc C st | j j rp | j r> | j d | r* d p- d | j f � n2 | j d | rS d pV d | j | � | j f � d S)Nz__Pyx_%sCLEAR(%s);rF r� z__Pyx_%sDECREF(%s); %s = 0;)r? r9 �
in_closurerV r� r- )rF r� r8 rI rI rJ rM 6 s z!CCodeWriter._put_var_decref_clearr c C sK xD | D]< } | s | j r | j r6 | j | � q | j | � q Wd S)N)rE Zxdecref_cleanuprL rK )rF �entriesZ used_onlyr� rI rI rJ �put_var_decrefsD s
zCCodeWriter.put_var_decrefsc C s" x | D] } | j | � q Wd S)N)rL )rF rQ r� rI rI rJ �put_var_xdecrefsL s
z CCodeWriter.put_var_xdecrefsc C s" x | D] } | j | � q Wd S)N)rO )rF rQ r� rI rI rJ �put_var_xdecrefs_clearP s
z"CCodeWriter.put_var_xdecrefs_clearc C sD d d l m } | j j | j � | j d | t | � f � d S)Nr )r z__PYX_INC_MEMVIEW(&%s, %d);)r� r r r� �memviewslice_init_coderV r� )rF � slice_cnamerC r rI rI rJ �put_incref_memoryviewsliceT s z&CCodeWriter.put_incref_memoryviewslicec C sD d d l m } | j j | j � | j d | t | � f � d S)Nr )r z __PYX_XDEC_MEMVIEW(&%s, %d);)r� r r r� rU rV r� )rF rV rC r rI rI rJ rG Y s z'CCodeWriter.put_xdecref_memoryviewslicec C s | j d | � d S)Nz
%s.memview)r4 )rF rV rI rI rJ � put_xgiveref_memoryviewslice^ s z(CCodeWriter.put_xgiveref_memoryviewslicec C sc d d l m } m } | | | d � } | rH | j d | | f � n | j d | | f � d S)Nr )r. r/ �Py_Nonez %s = %s; __Pyx_INCREF(Py_None);z %s = %s; Py_INCREF(Py_None);)r0 r. r/ rV )rF r� r? r6 r. r/ Zpy_nonerI rI rJ �put_init_to_py_nonea s
z CCodeWriter.put_init_to_py_nonez%sc C s= | | j } | j | | j | � | j r9 | j d � d S)NrY )r� rZ r? rP r3 )rF r� �templater6 rW rI rI rJ �put_init_var_to_py_nonei s
z#CCodeWriter.put_init_var_to_py_nonec C s� | j s | j d k rT | j t k rT | j d k rJ | j j d rJ n
| rT d Sd d l m } | j ry | j } n d } | j j
� } | r� | j r� | | g 7} | j d | j | j d j
| � | | f � d S) N�__getattribute__� __getattr__Z fast_getattrr )�method_coexistr z!{"%s", (PyCFunction)%s, %s, %s}%s�|)Z
is_specialry �special_py_methodsr r� Z TypeSlotsr_ �docZ doc_cname� signature� method_flagsrV Z
func_cnamerb )rF r� ZtermZ
allow_skipr_ Zdoc_coderd rI rI rJ �put_pymethoddefq s*
zCCodeWriter.put_pymethoddefc C s� | j j t j d d � � | j j d rK | j j t j d d � � n | j j t j d d � � | j d � | s� d } | r� | j d � | j d | � | j 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.
�ForceInitThreadszModuleSetupCode.c�fast_gil�FastGil� NoFastGilz#ifdef WITH_THREAD�__pyx_gilstate_savezPyGILState_STATE z %s = __Pyx_PyGILState_Ensure();z#endifN)r r� r� r� r� rV r� )rF �declare_gilstate�variablerI rI rJ �put_ensure_gil� s
zCCodeWriter.put_ensure_gilc C s� | j j d r/ | j j t j d d � � n | j j t j d d � � | sW d } | j d � | j d | � | j d � d S)
zD
Releases the GIL, corresponds to `put_ensure_gil`.
rg rh zModuleSetupCode.cri rj z#ifdef WITH_THREADz __Pyx_PyGILState_Release(%s);z#endifN)r r� r� r� r� rV )rF rl rI rI rJ �put_release_ensured_gil� s
z#CCodeWriter.put_release_ensured_gilc C s� | j j d r/ | j j t j d d � � n | j j t j d d � � | j d � | j d � | r| | j d | � | j d � | j d � d
S) z
Acquire the GIL. The thread's thread state must have been initialized
by a previous `put_release_gil`
rg rh zModuleSetupCode.cri z#ifdef WITH_THREADz__Pyx_FastGIL_Forget();z _save = %s;ZPy_BLOCK_THREADSz#endifN)r r� r� r� r� rV )rF rl rI rI rJ �put_acquire_gil� s
zCCodeWriter.put_acquire_gilc C s� | j j d r/ | j j t j d d � � n | j j t j d d � � | j d � | j d � | j d � | r� | j d | � | j d � | j d
� d S) z2Release the GIL, corresponds to `put_acquire_gil`.rg rh zModuleSetupCode.cri z#ifdef WITH_THREADzPyThreadState *_save;ZPy_UNBLOCK_THREADSz %s = _save;z__Pyx_FastGIL_Remember();z#endifN)r r� r� r� r� rV )rF rl rI rI rJ �put_release_gil� s
zCCodeWriter.put_release_gilc C s+ | j d � | j d � | j d � d S)Nz#ifdef WITH_THREADz%PyGILState_STATE __pyx_gilstate_save;z#endif)rV )rF rI rI rJ rk � s
z CCodeWriter.declare_gilstatec C s | j d | | j | � f � S)Nzif (%s < 0) %s)rV r� )rF r� r� rI rI rJ �put_error_if_neg� s z CCodeWriter.put_error_if_negc C s� d d l m } | j r5 d } | j j | j � nG | j j rc | rc d } | j j | j � n d } | j j | j � | j
d | j j | j � | | j
| j | � f � d S)Nr )� ExprNodesZ__Pyx_RaiseClosureNameErrorZ&__Pyx_RaiseUnboundMemoryviewSliceNogilZ __Pyx_RaiseUnboundLocalErrorz#if (unlikely(!%s)) { %s("%s"); %s })r� rr Z from_closurer r� Z%raise_closure_name_error_utility_coder? r: Z+raise_unbound_memoryview_utility_code_nogilZ&raise_unbound_local_error_utility_coderV Zcheck_for_null_coder� ry r� )rF r� r� Zin_nogil_contextrr �funcrI rI rJ �put_error_if_unbound� s"
z CCodeWriter.put_error_if_unboundc C s} d | j _ | r d | j _ | j j rC d t j t j f } n d } d t j t j | j
| d � t j | d | f S)NTz %s = %s;r� z%s = %s[%s]; %s = %s;%sr r ) r� r" r# r| r� r r# Z line_c_macror" �filetable_cnamer� r! )rF r� rE ZcinforI rI rJ �set_error_info� s zCCodeWriter.set_error_infoc C s> | j j } | j j | � d | j | d � | d | f S)Nz__PYX_ERR(%s, %s, %s)r r )r� r r6 r� )rF r� r5 rI rI rJ r� s zCCodeWriter.error_gotoc C s d | j | � | j | � f S)Nz
if (%s) %s)r( r� )rF r' r� rI rI rJ �
error_goto_if s zCCodeWriter.error_goto_ifc C s | j d | | � S)Nz!%s)rw )rF r� r� rI rI rJ r� s z CCodeWriter.error_goto_if_nullc C s | j d | | � S)Nz%s < 0)rw )rF r� r� rI rI rJ �error_goto_if_neg s z CCodeWriter.error_goto_if_negc C s | j d | � S)NzPyErr_Occurred())rw )rF r� rI rI rJ r s z CCodeWriter.error_goto_if_PyErrc C s | j j | � S)N)r r� )rF r� rI rI rJ r� s zCCodeWriter.lookup_filenamec C s | j d � d S)NZ__Pyx_RefNannyDeclarations)rV )rF rI rI rJ r� s z(CCodeWriter.put_declare_refcount_contextc C sI | r" | j j t j d d � � | j d | | r: d p= d f � d S)Nrf zModuleSetupCode.cz%__Pyx_RefNannySetupContext("%s", %d);r r )r r� r� r� rV )rF ry Z acquire_gilrI rI rJ r� s z&CCodeWriter.put_setup_refcount_contextc C s | j d � d S)Nz __Pyx_RefNannyFinishContext();)rV )rF rI rI rJ r� s z'CCodeWriter.put_finish_refcount_contextc C sH | | r t j n d t j t j f } d | j _ | 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 r# r! r" r� r# rV )rF �qualified_nameZ
include_cline� format_tuplerI rI rJ �put_add_traceback# s z CCodeWriter.put_add_tracebackc C sh | t j t j t j | j j d | f } d | j _ | j d | � | j j t
j 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.
�unraisable_tracebacksTz0__Pyx_WriteUnraisable("%s", %s, %s, %s, %d, %d);ZWriteUnraisableExceptionz Exceptions.cN) r r# r! r" r r� r� r# rV r� r� r� )rF ry �nogilrz rI rI rJ �put_unraisable2 s
zCCodeWriter.put_unraisablec C s | j d � d S)NZ__Pyx_TraceDeclarations)rV )rF rI rI rJ �put_trace_declarationsE s z"CCodeWriter.put_trace_declarationsc C s | r | j d | � d S)Nz__Pyx_TraceFrameInit(%s))rV )rF �codeobjrI rI rJ �put_trace_frame_initH s z CCodeWriter.put_trace_frame_initc C sD | j d | t j | j | d � | d | | j | � f � d S)Nz*__Pyx_TraceCall("%s", %s[%s], %s, %d, %s);r r )rV r ru r� r� )rF ry r� r} rI rI rJ �put_trace_callL s zCCodeWriter.put_trace_callc C s | j d � d S)Nz__Pyx_TraceException();)rV )rF rI rI rJ �put_trace_exceptionP s z CCodeWriter.put_trace_exceptionc C s | j d | | f � d S)Nz__Pyx_TraceReturn(%s, %d);)rV )rF Zretvalue_cnamer} rI rI rJ �put_trace_returnS s z CCodeWriter.put_trace_returnc C s+ | j d � | j | � | j d � d S)Nz#ifdef _OPENMPz#endif /* _OPENMP */)rV )rF �stringrI rI rJ � putln_openmpV s
zCCodeWriter.putln_openmpc C sV | j d | � | j d � | j d � | j d � | j d � | j d � d S)zl
Redefine the macros likely() and unlikely to no-ops, depending on
condition 'cond'
z#if %sz #undef likelyz #undef unlikelyz #define likely(x) (x)z #define unlikely(x) (x)z#endifN)rV )rF r' rI rI rJ �undef_builtin_expect[ s
z CCodeWriter.undef_builtin_expectc C sV | j d | � | j d � | j d � | j d � | j d � | j d � d S)Nz#if %sz #undef likelyz #undef unlikelyz2 #define likely(x) __builtin_expect(!!(x), 1)z2 #define unlikely(x) __builtin_expect(!!(x), 0)z#endif)rV )rF r' rI rI rJ �redef_builtin_expectg s
z CCodeWriter.redef_builtin_expect)�rZ r[ r\ r] r r| rK r� r� r� r� rY r� r� r� r� r r r r r r r� r r r r' r) r+ r/ r0 r1 r4 r6 r7 r� r� r� r� r� r� r� r� r� rk r� r� rV r r� r r r� r� r r r r r r r r r� r r r$ r% r& r( �modifier_output_mapperr, r- r1 r2 r3 r4 r5 r7 r: r; r< r= r> r? r@ rB rD rE r9 rI rJ rK rL rN rO rM rR rS rT rW rG rX rZ r\ re rm rn ro rp rk rq rt rv r� rw r� rx r r� r� r� r� r{ r~ r r� r� r� r� r� r� r� rI rI rI rJ 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 j | � | _ d | _ d S)Nr )r r r� r� )rF Z outfile_namerI rI rJ rK t s zPyrexCodeWriter.__init__c C s% | j j d d | j | f � d S)Nz%s%s
r) )r� rY r� )rF rW rI rI rJ rV x s zPyrexCodeWriter.putlnc C s | j d 7_ d S)Nr )r� )rF rI rI rJ r { s zPyrexCodeWriter.indentc C s | j d 8_ d S)Nr )r� )rF rI rI rJ �dedent~ s zPyrexCodeWriter.dedentN)rZ r[ r\ rK rV r r� rI rI rI rJ r� p s r� c @ s� e Z d Z d Z d d d 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 r1 c C s1 | p t � | _ | | _ | | _ | | _ d S)N)r
r� r� r� r� )rF r� � indent_levelr� r� rI rI rJ rK � s zPyxCodeWriter.__init__r c C s | j | 7_ d S)NT)r� )rF �levelsrI rI rJ r � s zPyxCodeWriter.indentc C s | j | 8_ d S)N)r� )rF r� rI rI rJ r� � s zPyxCodeWriter.dedentc C s | j | � | j � 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)rV r )rF r� rI rI rJ �indenter� s
zPyxCodeWriter.indenterc C s4 | j j � } t | t � r0 | j | j � } | S)N)r� r� r� r r� r� )rF rB rI rI rJ r� � s zPyxCodeWriter.getvaluec C s5 | p | j } | r$ t | | � } | j | � d S)N)r� r �_putln)rF r� r� rI rI rJ rV � s zPyxCodeWriter.putlnc C s% | j j d | j d | f � d S)Nz%s%s
z )r� rY r� )rF r� rI rI rJ r� � s zPyxCodeWriter._putlnc C s[ | p | j } | r$ t | | � } t j | � } x! | j � D] } | j | � q@ Wd S)N)r� r r r� r� r� )rF �chunkr� r� rI rI rJ � put_chunk� s zPyxCodeWriter.put_chunkc C s t | j j � | j | j � S)N)r� r� r� r� r� )rF rI rI rJ r� � s z PyxCodeWriter.insertion_pointc C s t | | | j � � d S)N)r� r� )rF ry rI rI rJ �named_insertion_point� s z#PyxCodeWriter.named_insertion_point)rZ r[ r\ r] rK r r� r� r� rV r� r� r� r� rI rI rI rJ r� � s r� c @ s4 e Z d Z d d � Z d d � Z d d � Z d S)rL c C s( | | _ i | _ i | _ d | _ d S)Nr )�klassr r � temps_count)rF r� rI rI rJ rK � s z ClosureTempAllocator.__init__c C s7 x0 | j j � D] \ } } t | � | j | <q Wd S)N)r rq r� r )rF r? r� rI rI rJ �reset� s zClosureTempAllocator.resetc C s� | | j k r, g | j | <g | j | <n! | j | rM | j | j d � Sd t j | j f } | j j d d d | d | d | d d � | j | j | � | j d 7_ | S)
Nr z%s%dr� ry r� r? Zis_cdefTr ) r r r; r r= r� r� Z declare_varr� )rF r? r� rI rI rJ rC � s
+z"ClosureTempAllocator.allocate_tempN)rZ r[ r\ rK r� rC rI rI rI rJ rL � s rL )L�
__future__r �cython�declare�objectr r r �sysr r r� r � functoolsr �
contextlibr � collectionsr r � ImportErrorr r� r r r r
r r ZScanningr r
Z __builtin__r �builtinsr � version_inforo r� Zbasicsize_builtins_mapZuncachable_builtinsrj ra rS r� r� r� r r9 rc rd r� r r r r
rN rQ r� �UrR rp rS r� rT �findallrU rV rg rn r� r� r� r� r� rL rI rI rI rJ �<module> s� !
L �� �
!O� � 5 � � � E