V]c@@sddlmZddlZddlmZmZmZmZmZm Z ddlm Z m Z m Z ddl mZmZmZmZddlmZd efd YZdS( i(tabsolute_importNi(t ExprNodest PyrexTypest MemoryViewtParseTreeTransformstStringEncodingtErrors(t CloneNodet ProxyNodet TupleNode(t FuncDefNodet CFuncDefNodet StatListNodetDefNodei(t OrderedSettFusedCFuncDefNodecB@s8eZdZd Zd Zd Zd Zd Ze j dddgZ dZ dZ dZ dZdZd Zd Zd Zd Zd ZdZdZdZdZdZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&RS(!s 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[:]) t__signatures__tresulting_fused_functiontfused_func_assignmentcC@stt|j|jg|_||_t|jt}|rS|j|n |j |x|jD]|}|j j j st |jjj st |jj r|jj st n| rj|jjrj|j jst qjqjW||j _|j|_dS(N(tsuperRt__init__tpostnodestnodet isinstanceR tcopy_deft copy_cdeftentryttypetis_fusedtAssertionErrort local_scopet return_typetcfunc_declaratortoptional_arg_countt op_arg_structtfused_cfunctiontstats(tselfRtenvtis_deftn((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyR2s      c C@stjg|jjD]}|jjr|j^q}|j|}tj|}||_|jj |j kr|j j |jj nx|D]\}}t j |j}|jj j|j _|j|j||jjj||_|j||j||||j|||jj ||tj|j |t|j _|j |j|j j<|j|sPqqW|j|_|j|j|dt|_dS(sh Create a copy of the original def or lambda function for specialized versions. R(N(RtuniqueRtargsRRt_get_fused_base_typest get_all_specialized_permutationstfused_compound_typesRtpyfunc_entriestremovetcopytdeepcopyt signaturet_specialize_function_argsR t specializetanalyse_declarationstcreate_new_local_scopetspecialize_copied_deftspecialize_entrytTruetusedtentriestnametreplace_fused_typecheckst orig_py_functmake_fused_cpdeftpy_func( R&R'targR.t fused_typest permutationstcnametfused_to_specifict copied_node((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyROs01       cC@s|jjj}|jj|_}d|j_|rM|jj|jn|jjj }||_ g}x|D]\}}t j |j}|jj |} |j} | j| |xt|jD]t\} } | j| jkr| j| jr|j| |_|jjs,| j|j_n|j} | j} PqqW|j| | |_| | | _| _| jp|jjjp|jp| j| _|jjjr|jjj| |d|n| j|_|j||||j|jj||j ||jrS|jj|jj|j!|j||jjj"||n|j#|suPququWy|jj$|jj} Wn!t%k r|jj&|nX||j| | d+|r|j'||dt(|_n ||_dS(sf Create a copy of the original c(p)def function for all specialized versions. t fused_cnameiR(N()RRR-RAR?tNoneR/R0Rtget_fused_typesR.R1R2R5R9t enumeratet cfunc_entriesREtsame_as_resolved_typet func_cnametappendR;tdefined_in_pxdtis_c_class_scopet is_cmethodR!R"tdeclare_optional_arg_structR R7R4R+tdeclare_cpdef_wrapperR8t as_variableR>tindext ValueErrortextendR@tFalse(R&R'RDR?RCtnew_cfunc_entriesRERFRGRRtit orig_entrytcindex((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyRxsh   $              cC@s:g}t}x$|D]}|jd|d|qW|S(sq Get a list of unique basic fused types, from a list of (possibly) compound fused types. tresulttseen(tsetRJ(R&R.t base_typesR_t fused_type((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyR,s   cC@s[xT|D]L}|jjr|jj||_|jjrS|jj|jqSqqWdS(N(RRR5tis_memoryviewslicetvalidate_memslice_dtypeR(R&R+RFRB((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyR4s    cC@s6|j|||j_t|_|jj|dS(s 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 N(tcreate_local_scopeRRFRYthas_fused_argumentsRRO(R&RR'tf2s((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyR7s   c C@s|j|}g|D]}tj||^q}dj||_tj||jj|j_|j|j_|j |j_ dS(swSpecialize the copy of a DefNode given the copied node, the specialization cname and the original DefNode entryt|N( R,Rtspecialization_signature_stringtjointspecialized_signature_stringtget_fused_cnameRtpymethdef_cnametdoct doc_cname( R&RREtpy_entryRgR.RCRbt type_strings((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyR8s"cC@s<tj}tj|j}||tj|kr8tStS(s 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. (Rt num_errorsRtReplaceFusedTypeChecksRRYR:(R&RGRrt transform((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyR>s   cC@sDx=|D]5}|jjd|jd|j|jdqWdS(sl Generate Cython code for instance checks, matching an object to specialized types. t py_type_nametspecialized_type_nameu if isinstance(arg, {{py_type_name}}): dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'; break N(tcontexttupdateRutspecialization_stringt put_chunk(R&t normal_typestpyx_codeR'tspecialized_type((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt_fused_instance_checkss     cC@s'|jrd|St|jddS(Ns ___pyx_%st t_(t is_typedeftstrtreplace(R&tdtype((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt _dtype_name&s cC@s |jr|j|St|S(N(RRR(R&R((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt _dtype_type+s  cC@s"|jr dSd|j|SdS(Nssizeof(void *)s sizeof(%s)(t is_pyobjectR(R&R((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt _sizeof_dtype0s cC@s|jdr6|jd|jd|jn|jdrl|jd|jd|jn|jdr|jd|jd|jn|jdr|jd|jd |jnd S( s?Setup some common cases to match dtypes against specializationssif kind in b'iu':tpasst dtype_intselif kind == b'f':t dtype_floatselif kind == b'c':t dtype_complexselif kind == b'O':t dtype_objectN(tindentertputlntnamed_insertion_pointtdedent(R&R|((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt%_buffer_check_numpy_dtype_setup_cases6s            s8dest_sig[{{dest_sig_idx}}] = '{{specialized_type_name}}'s!dest_sig[{{dest_sig_idx}}] = Nonec C@sX|j|xD||D]8}|}|jr9|j}n|j}|jjd|j|ddd|j|d|d|j|j |j f|j |j f|j |jfg}x|D]\}} |rd|jf} |j r| d7} n|jr | d 7} n| jd | rL| j|j| jd | jqLqqWqWd S( sO Match a numpy dtype object to the individual specializations. titemsize_matchs == itemsizet signed_matchs!not (%s_is_signed ^ dtype_signed)RRvs3{{itemsize_match}} and (arg.ndim) == %ds and {{signed_match}}s and arg_is_pythran_compatiblesif %s:tbreakN(Rtis_pythran_exprt org_bufferRRwRxRRRytis_intRtis_floatRt is_complexRtndimRRtmatchR( R&R|tspecialized_buffer_typest pythran_typesR}t final_typeRtdtypestdtype_categoryt codewritertcond((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt_buffer_check_numpy_dtypeNs4            cC@s|j}|jr%d g|j}n |j}tj||}|j||jjd|j d||j d|jjd|j d|j ||j d|jd S( s 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 tdirecttstridedtcoerce_from_py_funcRs;{{memviewslice_cname}} {{coerce_from_py_func}}(object, int)Rvt sizeof_dtypeu # 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(RR(Rt is_bufferRtaxesRtMemoryViewSliceTypetcreate_from_py_utility_codeRwRxtfrom_py_functionRRyRRzR(R&R|t decl_codeR}R'RRt memslice_type((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt!_buffer_parse_format_string_checkus          cC@s|jd|rdndd|r)dndd|jd|rX|jdn|jd |j||||jdx$|D]}|j||||qWd S( s^ 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. u u!arg_is_pythran_compatible = Falseuu if ndarray is not None: if isinstance(arg, ndarray): dtype = arg.dtype u arg_is_pythran_compatible = TrueuC 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' iuS # 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) tnumpy_dtype_checksN(RztindentRRRR(R&t buffer_typesRR|RR'R}((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt_buffer_checkss '     cC@s|jd|jjd|r6|jjdn|jjdt}x|D]}|j}|jr|jd|j|j||j fn|jj rVt ||kr|j t ||j jd|j|d|j||jjdqqVqVWd S( sr If we have any buffer specializations, write out some variable declarations and imports. u ctypedef struct {{memviewslice_cname}}: void *memview void __PYX_XDEC_MEMVIEW({{memviewslice_cname}} *, int have_gil) bint __pyx_memoryview_check(object) u cdef {{memviewslice_cname}} memslice cdef Py_ssize_t itemsize cdef bint dtype_signed cdef char kind itemsize = -1 ul cdef bint arg_is_pythran_compatible cdef Py_ssize_t cur_stride uq cdef type ndarray ndarray = __Pyx_ImportNumPyArrayTypeIfAvailable() sctypedef %s %s "%s"t dtype_namet dtype_typeu cdef bint {{dtype_name}}_is_signed {{dtype_name}}_is_signed = not (<{{dtype_type}}> -1 > 0) N(Rztlocal_variable_declarationstimportsR`RRRtresolveRtempty_declaration_codeRRtaddRwRxR(R&R|Rtall_buffer_typesRtseen_int_dtypest buffer_typeR((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt_buffer_declarationss.           c C@stj|j}|jt}ggg}}}t}x|D]}|j} | r| |krpqFn|j| | dkrt}q|j |qF|j r|j |qF|j s|j rF|j |qFqFW||||fS(sV Specialize fused types and split into normal types and buffer types. tobject( Rtget_specialized_typesRtsortR`RYRuRR:RORRRc( R&RBtspecialized_typestseen_py_type_namesR{RRthas_object_fallbackR}Ru((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt_split_fused_typess&         cC@s|jddS(Nu # 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}} (Rz(R&R|((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyt_unpack_argument0sc C@sddlm}m}m}|jg|jjD]}|jjr/|j^q/}it j d6|jjd6t |d6|r|jj |jj ntd|jjDd6|jjd6} |jd | } |jd | } | jd | j| jd | j| jd | jd | jdd} d} t}t}xt|jjD]\}}|jjr|jj}t |dkrtdn|d}n|jjr'||kr'|j|| jd|d|d| d| |j|\}}}}|j| | jdr|r\|j|| |n|sh|r|j |jj!dd|j"||| | |n|r| j#jdd| j$|j%n| j$|j&| j$d| j'n| d7} |j||jd|Dn|j(rm| d7} qmqmW|r|j)| | |||j |jj!dd|j |jj!ddn| jd| j*}dd l+m,}|j|d!d"d#|g}|j-|jj.|j/}|j0| j*|j1||_2|j3||j4d$}|j2|_5t6|jt7rm|j8|_9n"g|j8D]}|j:^qw|_9|S(%s! 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. i(t TreeFragmenttCodet UtilityCodetmemviewslice_cnamet func_argstn_fusedcs@s$|]}|jdkrdVqdS(iN(tdefaultRI(t.0RB((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pys Xstmin_positional_argsR=Rwu cdef extern from *: void __pyx_PyErr_Clear "PyErr_Clear" () type __Pyx_ImportNumPyArrayTypeIfAvailable() int __Pyx_Is_Little_Endian() u 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 Rt func_defsRisODetermination of more than one fused base type per argument is not implemented.t arg_tuple_idxRBt dest_sig_idxt default_idxswhile 1:tIsLittleEndiansModuleSetupCode.cRvRRcs@s|]}|jVqdS(N(R(Rtty((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pys stImportsImportExport.ctImportNumPyArrayu 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]] (tConstantFoldingtleveltmoduletpipelinei(;tRRRR,RR+RRRRtlentnum_required_argstnum_required_kw_argstsumRR=t PyxCodeWriterRzRRRR`RKRJtNotImplementedErrorRRxRRRR~tuse_utility_codet load_cachedRRwRRtno_matchRRRtgetvaluetOptimizeRtSetPosTransformRtroottdeclare_declarations_in_scopet global_scopetscopeR6R%tfragment_scopeRR Rtspecialized_cpdefsRA(R&R?R'R(RRRRBRCRwR|Rt fused_indexRRtseen_fused_typesR[targ_fused_typesRbR{RRRt fragment_codeRtfragmenttastRAR)((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyR@Es1                          "c C@sAd }|jj}x-|D]%}t||t|jj|qW|jj|j_|jj|j_|jjd dt |j t r||j|j__signatures__ = %s;(RRItgenerate_evaluation_codeRARR R%R"RRRtExprNodetgenerate_execution_codeRRRR^t put_giverefRtgenerate_disposal_code(R&R#RR((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyR&Us2     cC@s%x|jD]}|j|q WdS(N(R%tannotate(R&R#R((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyR){sN('t__name__t __module__t__doc__RIRRRRt decoratorsR t child_attrsRRRR,R4R7R8R>R~RRRRRRRRRRRRR@RRRR!R&R)(((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyR sH  ) V          ' ( = 9   # 2  &(t __future__RR1RRRRRRRRRR tNodesR R R R tUtilsRR(((s8lib/python2.7/site-packages/Cython/Compiler/FusedNode.pyts  ."