B Í‹d¢“ã@s€ddlmZddlZddlmZmZmZmZmZm Z ddlm Z m Z m Z ddl mZmZmZmZddlmZGd d „d eƒZdS) é)Úabsolute_importNé)Ú ExprNodesÚ PyrexTypesÚ MemoryViewÚParseTreeTransformsÚStringEncodingÚErrors)Ú CloneNodeÚ ProxyNodeÚ TupleNode)Ú FuncDefNodeÚ CFuncDefNodeÚ StatListNodeÚDefNodeé)Ú OrderedSetcseZdZdZdZdZdZdZdZe j dddgZ ‡fdd„Z dd „Z d d „Z d d „Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zd Zd!Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Z d0d1„Z!d2d3„Z"d4d5„Z#d6d7„Z$d8d9„Z%d:d;„Z&‡Z'S)<ÚFusedCFuncDefNodea÷ This node replaces a function with fused arguments. It deep-copies the function for every permutation of fused types, and allocates a new local scope for it. It keeps track of the original function in self.node, and the entry of the original function in the symbol table is given the 'fused_cfunction' attribute which points back to us. Then when a function lookup occurs (to e.g. call it), the call can be dispatched to the right function. node FuncDefNode the original function nodes [FuncDefNode] list of copies of node with different specific types py_func DefNode the fused python function subscriptable from Python space __signatures__ A DictNode mapping signature specialization strings to PyCFunction nodes resulting_fused_function PyCFunction for the fused DefNode that delegates to specializations fused_func_assignment Assignment of the fused function to the function name defaults_tuple TupleNode of defaults (letting PyCFunctionNode build defaults would result in many different tuples) specialized_pycfuncs List of synthesized pycfunction nodes for the specializations code_object CodeObjectNode shared by all specializations and the fused function fused_compound_types All fused (compound) types (e.g. floating[:]) NÚ__signatures__Úresulting_fused_functionÚfused_func_assignmentcs¸tt|ƒ |j¡g|_||_t|jtƒ}|r:| |¡n |  |¡xV|jD]L}|j j j r^t ‚|jjj rlt ‚|jj r€|jj r€t ‚|sL|jjrL|j jsLt ‚qLW||j _|jdd…|_dS)N)ÚsuperrÚ__init__ÚposÚnodesÚnodeÚ isinstancerÚcopy_defÚ copy_cdefÚentryÚtypeÚis_fusedÚAssertionErrorÚ local_scopeÚ return_typeÚcfunc_declaratorÚoptional_arg_countZ op_arg_structÚfused_cfunctionÚstats)ÚselfrÚenvÚis_defÚn)Ú __class__©úf/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/Cython/Compiler/FusedNode.pyr2s       zFusedCFuncDefNode.__init__cCst dd„|jjDƒ¡}| |¡}t |¡}||_|jj|jkrP|j  |jj¡x¨|D] \}}t   |j¡}|jjj |j_ |  |j|¡|jj |¡|_| |¡| |||¡| |||jj||¡t |j|¡d|j_|j|j|jj<| |¡sVPqVW|j|_|j|j|dd|_dS)zh Create a copy of the original def or lambda function for specialized versions. cSsg|]}|jjr|j‘qSr.)r r!)Ú.0Úargr.r.r/ú Usz.FusedCFuncDefNode.copy_def..T)r+N)rÚuniquerÚargsÚ_get_fused_base_typesÚ get_all_specialized_permutationsÚfused_compound_typesrÚpyfunc_entriesÚremoveÚcopyÚdeepcopyÚ signatureÚ_specialize_function_argsr$Ú specializeÚanalyse_declarationsÚcreate_new_local_scopeÚspecialize_copied_defÚspecialize_entryÚusedÚentriesÚnameÚreplace_fused_typechecksÚ orig_py_funcÚmake_fused_cpdefÚpy_func)r)r*r7Ú fused_typesÚ permutationsÚcnameÚfused_to_specificÚ copied_noder.r.r/rOs0     zFusedCFuncDefNode.copy_defcCs$|jj ¡}|jj|_}d|j_|r4|j |j¡|jj ¡}||_ g}xh|D]^\}}t   |j¡}|j  |¡} |j} |   | |¡xdt|jƒD]L\} } | j| jkr’|  | j¡r’|j| |_|jjsÐ| j|j_|j} | j} Pq’W| | ¡| |_| | | _| _| jp |jjjp |jp | j| _|jjjrD|jjj| ||d| j|_| |||¡| |jj|¡| |¡|jr¦|j |jj¡|  |j||jjj!||¡| "|¡sRPqRWy|j #|jj¡} Wn"t$k rì|j %|¡YnX||j| | d…<|r|j&||dd|_n||_dS)zf Create a copy of the original c(p)def function for all specialized versions. N)Z fused_cnamerF)r+)'rr r6rIrGr8r9rÚget_fused_typesr7r:r;r>rBÚ enumerateZ cfunc_entriesrLZsame_as_resolved_typeÚ func_cnameÚappendrCZdefined_in_pxdZis_c_class_scopeZ is_cmethodr%r&Zdeclare_optional_arg_structr$r@r=r4Zdeclare_cpdef_wrapperrAÚ as_variablerFÚindexÚ ValueErrorÚextendrH)r)r*rKrGrJZnew_cfunc_entriesrLrMrNr rÚiZ orig_entryZcindexr.r.r/rxsh               zFusedCFuncDefNode.copy_cdefcCs*g}tƒ}x|D]}|j||dqW|S)zq Get a list of unique basic fused types, from a list of (possibly) compound fused types. )ÚresultÚseen)ÚsetrO)r)r7Z base_typesrYÚ fused_typer.r.r/r5Îs  z'FusedCFuncDefNode._get_fused_base_typescCs>x8|D]0}|jjr|j |¡|_|jjr|j |j¡qWdS)N)r r!r>Úis_memoryviewsliceZvalidate_memslice_dtyper)r)r4rMr1r.r.r/r=Ùs  z+FusedCFuncDefNode._specialize_function_argscCs(| |¡||j_d|_|j |¡dS)a¥ Create a new local scope for the copied node and append it to self.nodes. A new local scope is needed because the arguments with the fused types are already in the local scope, and we need the specialized entries created after analyse_declarations on each specialized version of the (CFunc)DefNode. f2s is a dict mapping each fused type to its specialized version FN)Zcreate_local_scoper#rMZhas_fused_argumentsrrR)r)rr*Úf2sr.r.r/r@às z(FusedCFuncDefNode.create_new_local_scopecsT| |¡}‡fdd„|Dƒ}d |¡|_t ||jj¡|j_|j|j_|j|j_dS)zwSpecialize the copy of a DefNode given the copied node, the specialization cname and the original DefNode entrycsg|]}t |ˆ¡‘qSr.)rZspecialization_signature_string)r0r[)r]r.r/r2ösz;FusedCFuncDefNode.specialize_copied_def..ú|N) r5ÚjoinÚspecialized_signature_stringrZget_fused_cnamerÚpymethdef_cnameÚdocÚ doc_cname)r)rrLZpy_entryr]r7rJZ type_stringsr.)r]r/rAñs    z'FusedCFuncDefNode.specialize_copied_defcCs,tj}t |j¡}||ƒtj|kr(dSdS)zã Branch-prune fused type checks like if fused_t is int: ... Returns whether an error was issued and whether we should stop in in order to prevent a flood of errors. FT)r Ú num_errorsrZReplaceFusedTypeChecksr#)r)rNrdZ transformr.r.r/rFs  z*FusedCFuncDefNode.replace_fused_typecheckscCs2x,|D]$}|jj| ¡|jd| d¡qWdS)zl Generate Cython code for instance checks, matching an object to specialized types. )Ú py_type_nameÚspecialized_type_namez£ if isinstance(arg, {{py_type_name}}): dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'; break N)ÚcontextÚupdatereÚspecialization_stringÚ put_chunk)r)Ú normal_typesÚpyx_coder*Úspecialized_typer.r.r/Ú_fused_instance_checkss   z(FusedCFuncDefNode._fused_instance_checkscCs|jrd|St|ƒ dd¡S)Nz ___pyx_%sú Ú_)Ú is_typedefÚstrÚreplace)r)Údtyper.r.r/Ú _dtype_name&szFusedCFuncDefNode._dtype_namecCs|jr| |¡St|ƒS)N)rqrurr)r)rtr.r.r/Ú _dtype_type+s zFusedCFuncDefNode._dtype_typecCs|jr dSd| |¡SdS)Nzsizeof(void *)z sizeof(%s))Z is_pyobjectrv)r)rtr.r.r/Ú _sizeof_dtype0szFusedCFuncDefNode._sizeof_dtypecCsœ| d¡r&| d¡| d¡| ¡| d¡rL| d¡| d¡| ¡| d¡rr| d¡| d¡| ¡| d¡r˜| d¡| d ¡| ¡d S) z?Setup some common cases to match dtypes against specializationszif kind in b'iu':ÚpassÚ dtype_intzelif kind == b'f':Ú dtype_floatzelif kind == b'c':Ú dtype_complexzelif kind == b'O':Z dtype_objectN)ÚindenterÚputlnÚnamed_insertion_pointÚdedent)r)rlr.r.r/Ú%_buffer_check_numpy_dtype_setup_cases6s             z7FusedCFuncDefNode._buffer_check_numpy_dtype_setup_casesz8dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'z!dest_sig[{{dest_sig_idx}}] = Nonec Csì| |¡xÜ||D]Ð}|}|jr(|j}|j}|jj| |¡dd| |¡||jd|j |j f|j |j f|j |jfg}xh|D]`\}} |r€d|jf} |j r¦| d7} |jr´| d7} |  d| ¡r€|  |j¡|  d¡|  ¡q€WqWd S) zO Match a numpy dtype object to the individual specializations. z == itemsizez!not (%s_is_signed ^ dtype_signed))Zitemsize_matchZ signed_matchrtrfz3{{itemsize_match}} and (arg.ndim) == %dz and {{signed_match}}z and arg_is_pythran_compatiblezif %s:ÚbreakN)r€Úis_pythran_exprÚ org_bufferrtrgrhrwruriÚis_intryZis_floatrzÚ is_complexr{Úndimr|r}Úmatchr) r)rlZspecialized_buffer_typesÚ pythran_typesrmZ final_typertZdtypesZdtype_categoryZ codewriterZcondr.r.r/Ú_buffer_check_numpy_dtypeNs4         z+FusedCFuncDefNode._buffer_check_numpy_dtypecCs~|j}|jrdg|j}n|j}t ||¡}| |¡|jj|j |d|  d¡|jj|j |  |¡d|  d|j¡dS)zô For each specialized type, try to coerce the object to a memoryview slice of that type. This means obtaining a buffer and parsing the format string. TODO: separate buffer acquisition from format parsing )ÚdirectZstrided)Zcoerce_from_py_funcrtz;{{memviewslice_cname}} {{coerce_from_py_func}}(object, int))rfZ sizeof_dtypeaæ # try {{dtype}} if itemsize == -1 or itemsize == {{sizeof_dtype}}: memslice = {{coerce_from_py_func}}(arg, 0) if memslice.memview: __PYX_XDEC_MEMVIEW(&memslice, 1) # print 'found a match for the buffer through format parsing' %s break else: __pyx_PyErr_Clear() N)rtÚ is_bufferr†ÚaxesrZMemoryViewSliceTypeZcreate_from_py_utility_codergrhZfrom_py_functionr}rirwrjr‡)r)rlÚ decl_codermr*rtrŒZ memslice_typer.r.r/Ú!_buffer_parse_format_string_checkus    z3FusedCFuncDefNode._buffer_parse_format_string_checkcCs†| d|rdndd|rdndd¡| d¡|rB| d¡| d ¡| |||¡| d¡x|D]}| ||||¡qjWd S) a^ Generate Cython code to match objects to buffer specializations. First try to get a numpy dtype object and match it against the individual specializations. If that fails, try naively to coerce the object to each specialization, which obtains the buffer each time and tries to match the format string. z z!arg_is_pythran_compatible = FalseÚzœ if ndarray is not None: if isinstance(arg, ndarray): dtype = arg.dtype z arg_is_pythran_compatible = TrueaC elif __pyx_memoryview_check(arg): arg_base = arg.base if isinstance(arg_base, ndarray): dtype = arg_base.dtype else: dtype = None else: dtype = None itemsize = -1 if dtype is not None: itemsize = dtype.itemsize kind = ord(dtype.kind) dtype_signed = kind == 'i' raS # Pythran only supports the endianness of the current compiler byteorder = dtype.byteorder if byteorder == "<" and not __Pyx_Is_Little_Endian(): arg_is_pythran_compatible = False elif byteorder == ">" and __Pyx_Is_Little_Endian(): arg_is_pythran_compatible = False if arg_is_pythran_compatible: cur_stride = itemsize shape = arg.shape strides = arg.strides for i in range(arg.ndim-1, -1, -1): if (strides[i]) != cur_stride: arg_is_pythran_compatible = False break cur_stride *= shape[i] else: arg_is_pythran_compatible = not (arg.flags.f_contiguous and (arg.ndim) > 1) Znumpy_dtype_checksN)rjÚindentr~r‰rrŽ)r)Ú buffer_typesrˆrlrr*rmr.r.r/Ú_buffer_checkss     z FusedCFuncDefNode._buffer_checksc CsØ| d¡|j d¡|r&|j d¡|j d¡tƒ}tƒ}x”|D]Œ}|j}| |¡} |jrŒ| |krŒ| | ¡| d|  ¡| |  ¡f¡|jj rDt |ƒ|krD| t |ƒ¡|j j| | |¡d|j d¡qDWdS) zr If we have any buffer specializations, write out some variable declarations and imports. zì ctypedef struct {{memviewslice_cname}}: void *memview void __PYX_XDEC_MEMVIEW({{memviewslice_cname}} *, int have_gil) bint __pyx_memoryview_check(object) zÐ cdef {{memviewslice_cname}} memslice cdef Py_ssize_t itemsize cdef bint dtype_signed cdef char kind itemsize = -1 zl cdef bint arg_is_pythran_compatible cdef Py_ssize_t cur_stride zq cdef type ndarray ndarray = __Pyx_ImportNumPyArrayTypeIfAvailable() zctypedef %s %s "%s")Ú dtype_nameZ dtype_typez­ cdef bint {{dtype_name}}_is_signed {{dtype_name}}_is_signed = not (<{{dtype_type}}> -1 > 0) N)rjÚlocal_variable_declarationsÚimportsrZrtrurqÚaddr}ÚresolveZempty_declaration_coder„rrrgrhrv) r)rlrÚall_buffer_typesrˆZ seen_typedefsZseen_int_dtypesZ buffer_typertr“r.r.r/Ú_buffer_declarationsÚs6     z&FusedCFuncDefNode._buffer_declarationsc Csªt |j¡}| ¡tƒ}ggg}}}d}xn|D]f}| ¡} | rr| |krNq4| | ¡| dkrfd}qš| |¡q4|jr„| |¡q4|j s|j r4| |¡q4W||||fS)zV Specialize fused types and split into normal types and buffer types. FÚobjectT) rZget_specialized_typesr ÚsortrZrer–rRr‚r‹r\) r)r1Zspecialized_typesZseen_py_type_namesrkr‘rˆÚhas_object_fallbackrmrer.r.r/Ú_split_fused_typess&      z$FusedCFuncDefNode._split_fused_typescCs| d¡dS)Na“ # PROCESSING ARGUMENT {{arg_tuple_idx}} if {{arg_tuple_idx}} < len(args): arg = (args)[{{arg_tuple_idx}}] elif kwargs is not None and '{{arg.name}}' in kwargs: arg = (kwargs)['{{arg.name}}'] else: {{if arg.default}} arg = (defaults)[{{default_idx}}] {{else}} {{if arg_tuple_idx < min_positional_args}} raise TypeError("Expected at least %d argument%s, got %d" % ( {{min_positional_args}}, {{'"s"' if min_positional_args != 1 else '""'}}, len(args))) {{else}} raise TypeError("Missing keyword-only argument: '%s'" % "{{arg.default}}") {{endif}} {{endif}} )rj)r)rlr.r.r/Ú_unpack_argument2sz"FusedCFuncDefNode._unpack_argumentcCs0ddlm}m}m}| dd„|jjDƒ¡}tj|jjt |ƒ|rP|jj |jj nt dd„|jjDƒƒ|j jdœ}|j|d} |j|d} |  d ¡|  ¡|  d ¡|  ¡|  d ¡|  d ¡|  d ¡d} d} tƒ} tƒ}x^t|jjƒD]L\}}|jjr*|j ¡}t |ƒdkr"tdƒ‚|d}|jjr.||kr.| |¡|j||| | d| |¡\}}}}| | ¡|  d¡r|r–| || |¡|s¢|rÈ|  |j !dd¡¡| "||| | |¡|rê| j#jdd|  $|j%¡n |  $|j&¡|  $d¡|  '¡| d7} |  |¡|  dd„|Dƒ¡|j(rî| d7} qîW| r~| )| | | |¡|  |j !dd¡¡|  |j !dd¡¡|  d¡|  *¡}ddl+m,}|j|d|ƒgd}| -|jj.¡|j/ƒ}| 0|  *¡| 1¡¡||_2| 3|¡|j4d}|j2|_5t6|jt7ƒr|j8d d …|_9nd!d„|j8Dƒ|_9|S)"a! This creates the function that is indexable from Python and does runtime dispatch based on the argument types. The function gets the arg tuple and kwargs dict (or None) and the defaults tuple as arguments from the Binding Fused Function's tp_call. r)Ú TreeFragmentÚCodeÚ UtilityCodecSsg|]}|jjr|j‘qSr.)r r!)r0r1r.r.r/r2Qsz6FusedCFuncDefNode.make_fused_cpdef..css|]}|jdkrdVqdS)Nr)Údefault)r0r1r.r.r/ú Zsz5FusedCFuncDefNode.make_fused_cpdef..)Úmemviewslice_cnameZ func_argsZn_fusedZmin_positional_argsrE)rgzß cdef extern from *: void __pyx_PyErr_Clear "PyErr_Clear" () type __Pyx_ImportNumPyArrayTypeIfAvailable() int __Pyx_Is_Little_Endian() aå def __pyx_fused_cpdef(signatures, args, kwargs, defaults): # FIXME: use a typed signature - currently fails badly because # default arguments inherit the types we specify here! dest_sig = [None] * {{n_fused}} if kwargs is not None and not kwargs: kwargs = None cdef Py_ssize_t i # instance check body r•Z func_defsr”rzODetermination of more than one fused base type per argument is not implemented.)Z arg_tuple_idxr1Z dest_sig_idxÚ default_idxzwhile 1:ZIsLittleEndianzModuleSetupCode.crš)rfrcss|] }|jVqdS)N)rƒ)r0Útyr.r.r/r£¨sÚImportzImportExport.cZImportNumPyArraya¿ candidates = [] for sig in signatures: match_found = False src_sig = sig.strip('()').split('|') for i in range(len(dest_sig)): dst_type = dest_sig[i] if dst_type is not None: if src_sig[i] == dst_type: match_found = True else: match_found = False break if match_found: candidates.append(sig) if not candidates: raise TypeError("No matching signature found") elif len(candidates) > 1: raise TypeError("Function call with ambiguous argument types") else: return (signatures)[candidates[0]] )ÚConstantFoldingÚmodule)ÚlevelZpipelineéÿÿÿÿNcSsg|] }|j‘qSr.)rI)r0r,r.r.r/r2Þs):rrŸr r¡r5rr4rr¤ÚlenZnum_required_argsZnum_required_kw_argsÚsumrrEZ PyxCodeWriterrjrr~rrZrPr r!rOÚNotImplementedErrorr–rhrržr|rnZuse_utility_codeZ load_cachedr’rgr}r‡Úno_matchrr¢r™ÚgetvalueZOptimizer¨ZSetPosTransformrÚrootZdeclare_declarations_in_scopeZ global_scopeÚscoper?r(Zfragment_scoperrrZspecialized_cpdefs)r)rGr*r+rŸr r¡rJrgrlrZ fused_indexr¥r˜Zseen_fused_typesrWr1Zarg_fused_typesr[rkr‘rˆrœZ fragment_coder¨ÚfragmentÚastrIr.r.r/rHGsš                   z"FusedCFuncDefNode.make_fused_cpdefcCsæd}|jj}x"|D]}t||t|jj|ƒƒqW|jj|j_|jj|j_|j dd¡t |j t ƒrp||j|j<n||j|j_ |j  |¡||jj_x6|jD],}t |j t ƒr¶|j|_qœ|j|j_||j_ qœW| ¡|j |j¡dS)N) rErrLrQZ pyfunc_cnamerarbrcZ is_memberr²Z__pyx_fused_cpdef)rIrÚsetattrÚgetattrrGrErbrDÚpoprrrrSr8rRr'rZ fused_py_funcÚsynthesize_defnodesr(r)r)r*Zcopy_attributesrÚattrrr.r.r/Úupdate_fused_defnode_entryâs(           z,FusedCFuncDefNode.update_fused_defnode_entryc Csx@|jD]6}x0| ¡D]$}x|jD]}|jr"| |¡q"WqWqW|jr€|j |¡|_|j |¡|_|j |¡|_|j  |¡|_ g|_ }x@|j j D]4}|j r¾|j  |¡|_ | t|j ƒ¡q”| d¡q”Wxnt|jƒD]`\}}| |¡}|j|<t|tƒrØx8t|j |ƒD](\}} | dk r t| ƒ |j|¡|_ q WqØW|jrþdd„|Dƒ} t|j| d|_|jj|dd |¡|_t|jƒ|_t|jdjƒ|_|jj} t|jƒ| _t|jƒ| _xDt|jƒD]6\}} t|jƒ| _|  |¡} |j|<t|jƒ| _qÄW|S)z‘ Analyse the expressions. Take care to only evaluate default arguments once and clone the result for all specializations NcSsg|]}|rt|ƒ‘qSr.)r )r0r¢r.r.r/r2'sz9FusedCFuncDefNode.analyse_expressions..)r4T)Z skip_childrenr) r7rOÚtypesr…Zcreate_declaration_utility_coderIrÚanalyse_expressionsrrÚdefaultsrr4r¢rRr rPr(rr Úzipr Z coerce_tor r rÚdefaults_tupleZ analyse_typesZcoerce_to_pyobjectÚspecialized_pycfuncsÚ code_objectr1) r)r*Zfused_compound_typer[Zspecialization_typer½r1rWÚstatr¢r4Z fused_funcZpycfuncr.r.r/r¼sH         z%FusedCFuncDefNode.analyse_expressionscCsŽt|jdtƒr"dd„|jDƒ}n|j}dd„|Dƒ}dd„t||ƒDƒ}dd„|Dƒ}tj |jt||ƒ¡|_||_ x|D] }d|_ q|WdS) zT Create the __signatures__ dict of PyCFunctionNode specializations. rcSsg|] }|j‘qSr.)rI)r0rr.r.r/r2<sz9FusedCFuncDefNode.synthesize_defnodes..cSsg|]}t |j¡‘qSr.)rZ EncodedStringr`)r0rr.r.r/r2@scSs g|]\}}tj|j|d‘qS))Úvalue)rZ StringNoder)r0rÚsigr.r.r/r2BscSsg|]}tjj|dd‘qS)T)Zbinding)rZPyCFunctionNodeZ from_defnode)r0rr.r.r/r2DsTN) rrrr¾rZDictNodeZ from_pairsrrrÀZis_specialization)r)rZ signaturesÚkeysÚvaluesZ pycfuncnoder.r.r/r¸7s z%FusedCFuncDefNode.synthesize_defnodescCsZ|jrd|j_|j ||¡x8|jD].}t|tƒr$|jjr$|  |j ¡| ||¡q$WdS)NT) rIZpymethdef_requiredrÚgenerate_function_definitionsr(rr rrCÚmark_posr)r)r*ÚcoderÂr.r.r/rÇMs  z/FusedCFuncDefNode.generate_function_definitionscCs`x |jD]}|dk r| |¡qW|jr@|j |¡|j |¡x<|jD]2}| |j¡t|t j ƒrp| |¡qH|  |¡qHW|j r,|j  |¡| d|j  ¡|j  ¡f¡| |j  ¡¡|j  |¡|j  |¡|j  |¡|j  |¡|j  |¡|j |¡|j |¡|j |¡|j |¡x.|jD]$}|dk r4| |¡| |¡q4WdS)Nz8((__pyx_FusedFunctionObject *) %s)->__signatures__ = %s;)r½Zgenerate_evaluation_coderIr¿rÁr(rÈrrrZExprNodeÚgenerate_execution_coderrr}rXZ put_giverefZgenerate_post_assignment_codeZ free_tempsrZgenerate_disposal_code)r)rÉr¢rÂr.r.r/rÊWs>                    z)FusedCFuncDefNode.generate_execution_codecCsx|jD]}| |¡qWdS)N)r(Úannotate)r)rÉrÂr.r.r/r˃s zFusedCFuncDefNode.annotate)(Ú__name__Ú __module__Ú __qualname__Ú__doc__rrrr¿Z decoratorsrZ child_attrsrrrr5r=r@rArFrnrurvrwr€r‡r¯r‰rŽr’r™rržrHrºr¼r¸rÇrÊrËÚ __classcell__r.r.)r-r/r sJ  )V '(=;#2 ,r)Ú __future__rr:rrrrrrr r r r ZNodesr rrrZUtilsrrr.r.r.r/Ús