o @a @s.dZddlmZmZmZddlmZmZmZmZddlm Z m Z m Z ddlm Z m Z ddlmZmZmZmZddlmZmZmZmZmZddlmZmZmZmZdd lmZmZmZmZm Z dd lm!Z!m"Z"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(dd l)m*Z*dd l+m,Z,ddl-m.Z.m/Z/ddl-m0Z0ddl1m2Z2m3Z3ddl4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:m;Z;ddl6mm?Z?m@Z@ddlAmBZBmCZCddlDZEddlFZFddlGmHZHddlIZIGddde*ZJd,ddZKddZLGdddZMd d!ZN d-d"d#ZO d,d$d%ZPGd&d'd'eEjQZRGd(d)d)eRZSGd*d+d+e*ZTdS).z~ This module contains all pythran backends. * Cxx dumps the AST into C++ code * Python dumps the AST into Python code )LocalNodeDeclarationsGlobalDeclarationsScope) YieldPoints IsAssigned ASTMatcherAST_any) RangeValuesPureExpressions Dependencies) Immediates Ancestors)TemplateInclude NamespaceCompilationUnit) StatementBlockAnnotatedStatementTypedefLabel)ValueFunctionDeclarationEmptyStatementNop) FunctionBodyLineReturnStatementStructAssign)ForWhile TryExcept ExceptHandlerIfAutoFor) OMPDirective)Backend)PythranSyntaxError)operator_to_lambdaupdate_operator_to_lambda) pythran_ward)PYTYPE_TO_CTYPE_TABLETYPE_TO_SUFFIX)Types) attr_to_pathpushpopcxxidisstrisnum) isextsliceispowi)metadataunparse)isnanisinfN)reducecs(eZdZdZfddZddZZS)Pythona Produces a Python representation of the AST. >>> import gast as ast, pythran.passmanager as passmanager >>> node = ast.parse("print('hello world')") >>> pm = passmanager.PassManager('test') >>> print(pm.dump(Python, node)) print('hello world') csd|_tt|dSN)resultsuperr;__init__self __class__1/usr/lib/python3/dist-packages/pythran/backend.pyr@-szPython.__init__cCs"t}t||||_dSN)ioStringIOr7ZUnparsergetvaluer>)rBnodeoutputrErErFvisit1s z Python.visit)__name__ __module__ __qualname____doc__r@rM __classcell__rErErCrFr;"s r;cCs4|s dgt|}|rtddt||D|S|S)NcSs*g|]\}}d||rd|ndqS)ztypename {0} {1}= {0}r=format).0tdrErErF <sztemplatize..)lenrzip)rKtypesZ default_typesrErErF templatize7sr]csfdd}|S)a Decorator for loop node (For and While) to handle "else" branching. Decorated node will save flags for a goto statement used instead of usual break and add this flag at the end of the else statements. Examples -------- >> for i in range(12): >> if i == 5: >> break >> else: >> ... some code ... Becomes >> for(type i : range(12)) >> if(i==5) >> goto __no_breaking0; >> ... some code ... >> __no_breaking0; cs|js!tjd|}Wd|S1swY|Sdt|}tj| |}Wdn1s>wYfdd|jD}|jvrXt|g}ng}t|g||S)zw New decorate function. It push the breaking flag, run the visitor and add "else" statements. Nz__no_breaking{0}cg|]}|qSrErMrVstmtrArErFrYjz2cxx_loop..loop_visitor..)orelser0break_handlersrUid used_breakrr)rBrKresZ break_handlerrcZ orelse_labelr_rArF loop_visitorZs      zcxx_loop..loop_visitorrE)rMrhrEr_rFcxx_loopCs ric@s&eZdZdddZddZddZdS) CachedTypeVisitorNcCsL|durt|_t|_t|_dS|j|_|j|_|j|_dSrG)dictcachercachemappingcopy)rBotherrErErFr@us   zCachedTypeVisitor.__init__cCs||jvr=||}||jvr=||jvr+|j|j||j|<|j|j||j|<n||j|<t|j|j|<||j|<d|j|S)Nz __type{0})rngeneratermrlrZrU)rBrKrWrErErF__call__s      zCachedTypeVisitor.__call__cCslt|jddd}t}t}|D] \}}||vr3dt|}|tt|j ||| |q|S)NcS|dS)NrExrErErFz,CachedTypeVisitor.typedefs..keyZ__type) sortedrnitemslistsetstrappendrrrladd)rBZkvLZvisitedkvtypenamerErErFtypedefss   zCachedTypeVisitor.typedefsrG)rNrOrPr@rrrrErErErFrjss  rjcCs|rd|SdS)NrSr=rT)rXrErErF make_defaultsrcCs|dur dgt|}|durg}t}t|jjt|jj} tt|||D]'\} \} } } t|ts8| | kr;d}nd}t| |d | t | }| |q(t t|||g|RS)Nr=z&&{0}{1}) rZr}argsdefaults enumerater[ isinstance CxxGeneratorrrUrrr)rBrKrtypenameftypesfargsrZ attributesZ argumentsZ first_defaultirWarXZ rvalue_refargumentrErErFmake_function_declarations rc Cst|||||||dgS)Nconst)r)rBrKrrrrrrErErFmake_const_function_declarationsrcseZdZdZddZddZddZdd Zfd d Zdkd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zed1d2Zed3d4Zd5d6Zd7d8Zd9d:Z d;d<Z!d=d>Z"d?d@Z#dAdBZ$dCdDZ%dEdFZ&dGdHZ'dIdJZ(dKdLZ)dMdNZ*dOdPZ+dQdRZ,dSdTZ-dUdVZ.dWdXZ/dYdZZ0d[d\Z1d]d^Z2d_d`Z3dadbZ4dcddZ5dedfZ6dgdhZ7didjZ8Z9S)l CxxFunctionaz Attributes ---------- ldecls : {str} set of local declarations. break_handler : [str] It contains flags for goto statements to jump on break in case of orelse statement in loop. None means there are no orelse statement so no jump are requiered. (else in loop means : don't execute if loop is terminated with a break) cCs&||_g|_t|_d|_t|_dSz4 Basic initialiser gathering analysis informations. N)parentrdr~rfldecls openmp_deps)rBrrErErFr@s  zCxxFunction.__init__cCs t|j|SrG)getattrr)rBattrrErErF __getattr__s zCxxFunction.__getattr__c Gsp|j||}||j}|s|Sg}|D]}||}td||}||q|j|t ||gS)z Declare variable local to node and insert declaration before. Not possible for function yielding values. {} {}) scope differencertypeofrrUrrdifference_updater) rBrK node_visitedskippedZ local_varsZlocals_visitedZvarnameZvartypeZdeclrErErFprocess_localss    zCxxFunction.process_localscCs4|jdd|jD|jdd|jDdS)Ncs|]}|jVqdSrGrerVrXrErErF z1CxxFunction.visit_OMPDirective..csrrGrrrErErFrr)rupdate private_deps shared_depsrBrKrErErFvisit_OMPDirectiveszCxxFunction.visit_OMPDirectivecst||tt||SrG)r6rMr?rrrCrErFrMs zCxxFunction.visitNcslt|t}|r4t}|D]}fdd|jD|_||q |dur+t||}|St|||||<|S)z Add OpenMP pragma on the correct stmt in the correct order. stmt may be a list. On this case, index have to be specify to add OpenMP on the correct statement. cr^rEr_)rVZdeprArErFrYrbz8CxxFunction.process_omp_attachements..N)r6getr&r}depsrr)rBrKraindexZomp_directivesZ directives directiverErArFprocess_omp_attachementss   z$CxxFunction.process_omp_attachementscCs,t|tr ||j|S|j||jSrG)rrr local_namesr\rqlctxrrErErFrs zCxxFunction.typeofcs|jj}dd|D}ddtt|D}tt|}dd|D_jdd|Dt_ dd|D_ fd d|j D}|||fS) NcSsg|]}t|jqSrE)r1rerVargrErErFrYrbz;CxxFunction.prepare_functiondef_context..cSsg|]}dt|qS)Z argument_type)r)rVrrErErFrYcSi|]}|j|qSrEr)rVZsymrErErF z;CxxFunction.prepare_functiondef_context..cSrrErrrErErFr rcSh|]}|jqSrErrVnrErErF z:CxxFunction.prepare_functiondef_context..cr^rEr_r`rArErFrYrb) rrangerZr~gatherrrrrjrrbody)rBrKr formal_args formal_typesZ local_declsrrErArFprepare_functiondef_contexts z'CxxFunction.prepare_functiondef_contextcsdgt|jjt|jjfdd|jjD}dgt|jjt|jjfdd|jjD}j|d}ttdd}|jvrNttddnt}|||||fS)Ncr^rEr_rrArErFrYrbz-CxxFunction.prepare_types..csg|]}j|qSrE)r\rrArErFrYrbrvoidcallableZpure)rZrrr\rrpure_expressionsr)rBrK dflt_argv dflt_argt result_type callable_type pure_typerErArF prepare_typesszCxxFunction.prepare_typesc slt|j_|}|\}}}|}|\}}}} } d|r(dd|nd} dj| } tt|d| d|||||t g} t|d| dj||}t j fd d j D} }tt||t|||}t fd d j|d Dtt|d g} |}ttd|||g}tj| | g|| }|g|gfS)Nz type{0}::<{0}>, r=z{0}::{1}ztypename {0}result_type operator(){0}::operator()cs2g|]}tdjj|t|qSz{0} {1})rrUr\rrqr1rVrctxrBrErFrYIs  z1CxxFunction.visit_FunctionDef..c"g|] }tt||jqSrErrrqrrVrWrrErFrYWrtrtype)r1rfnamerrrUjoinr]rrrjrrrrrr\rrrqr)rBrKtmp operator_bodyrrrrrrrZfscopeZffscopeoperator_declarationoperator_signatureZoperator_local_declarationsZdependent_typedefsoperator_definitionextra_typedefsZreturn_declaration topstructrErrFvisit_FunctionDef's            zCxxFunction.visit_FunctionDefcCsV||j}t|tjr!d|j}ttd||t dg}nt |}| ||S)Nztypename {}::type::result_typezstatic %s tmp_globalZ tmp_global) rMvaluer6rZ StaticReturnrUrrrrr)rBrKrrrarErErF visit_Returnls   zCxxFunction.visit_ReturncCtSrGrrB_rErErF visit_Delete{zCxxFunction.visit_Deletec sxtdd|jDstd||j}fdd|jD}d|}t|dkoFt|jdtj oF|jdj j |voF|jdj j v}|rj d d|jDj|jdrld |jd|}nEtj|jdjjjrd jjjjd ||}n#tj|jdjjjsJd jjjjd ||}t||}||S) ar Create Assign node for final Cxx representation. It tries to handle multi assignment like: >> a = b = c = 2 If only one local variable is assigned, typing is added: >> int a = 2; TODO: Handle case of multi-assignement for some local variables. Finally, process OpenMP clause like #pragma omp atomic css"|] }t|tjtjfVqdSrG)rastNameZ SubscriptrrErErFrsz+CxxFunction.visit_Assign..z+Must assign to an identifier or a subscriptcr^rEr_rrArErFrYrbz,CxxFunction.visit_Assign..= rtrcsrrGrrrErErFrrrz decltype({}))alltargetsr(rMrrrZrrrrerrrrr\Z iscombinedrUrbuilder AssignableZAssignableNoEscapeZ NamedTypeZLazyrr)rBrKrr alltargetsislocalrarErArF visit_Assign~s^     zCxxFunction.visit_AssigncCsH||j}||j}tt|j}t|||dd}|||S)Nrt)rMrtargetr*roprr)rBrKrrrrarErErFvisit_AugAssigns   zCxxFunction.visit_AugAssigncs@fdd|jD}td|jrdndd|}||S)Ncr^rEr_rrArErFrYrbz+CxxFunction.visit_Print..z!pythonic::builtins::print{0}({1})r=Z_nonlr)valuesrrUnlrr)rBrKrrarErArF visit_Prints   zCxxFunction.visit_PrintcCsft|j|D]'}t|tjsdSt|tD]}d|jvr-||j vr)t d|dSqqJd)NFZcollapsez@not pure expression used as loop target inside a collapse clauseTzunreachable state) reversedZ ancestorsrrr r6rr&srr()rBlooprKZancestorrrErErFis_in_collapses    zCxxFunction.is_in_collapsec Csdt|}|jj|}|jj|jvo#|jj|j|vo#t|d }|r1d} |j |jjnd} t d| ||} | |||} t d| d||d|t| |g} ||| gS) ao Create For representation on iterator for Cxx generation. Examples -------- >> "omp parallel for" >> for i in range(10): >> ... do things ... Becomes >> "omp parallel for shared(__iterX)" >> for(decltype(__iterX)::iterator __targetX = __iterX.begin(); __targetX < __iterX.end(); ++__targetX) >> auto&& i = *__targetX; >> ... do things ... It the case of not local variable, typing for `i` disappear and typing is removed for iterator in case of yields statement in function. __target{0}yieldszauto&&r=z {} {}= *{}z {}.begin()z{0} < {1}.end()z++{0})rUrer\rZIteratorOfTyperrrhasattrrremover make_assignr rr) rBrKr local_iterlocal_iter_decl loop_bodyZ local_targetZlocal_target_declrZ local_typeZloop_body_preludeZassignrrErErFgen_fors,    zCxxFunction.gen_forcCst|dkr d}n5t|drddt|djdk}n!t|dr {})rZr3intrrU)rBrr upper_boundZorder comparisonrErErFhandle_real_loop_comparisons  & z'CxxFunction.handle_real_loop_comparisoncCsj|jj}t|dkr dn||d}t|dkrd}d}n ||d}d}d}} |||} ||||r=| } ndt|} |jj|jvoY|jj|j |voYt |d } | rht } |j |jjnd } td || td ||g} |||| }td | |||d |||}| d|||| | urg}|| fS||| | }t|g}|| fS)a) Create C For representation for Cxx generation. Examples -------- >> for i in range(10): >> ... do things ... Becomes >> for(long i = 0, __targetX = 10; i < __targetX; i += 1) >> ... do things ... Or >> for i in range(10, 0, -1): >> ... do things ... Becomes >> for(long i = 10, __targetX = 0; i > __targetX; i += -1) >> ... do things ... It the case of not local variable, typing for `i` disappear rZ1LrtZ0Lrzlong rr r=z{} == {}z{} -= {}z {0} {1}={2}z {0} += {1})iterrrZrMrrUrerrrr r}rr r$rrr insertrr )rBrKr rrstepZ lower_boundZ upper_argZ upper_typeZ iter_typeZ upper_valuerrrrZforloopheaderZassgntrErErF gen_c_forsN     zCxxFunction.gen_c_forc st|tD]ytfdddDr1jd7_jt|t ddj jd|j t tjs.)z parallel z task z shared({})Nrfordefaultc3s(|]}t|tjo|jjkVqdSrG)rrrre)rVrv)rrErFrys   z private({}))r6rr&anyrrrrrLoadrrrrrerr)rBrKr ZhasforZ nodefaultZ noindexrefrE)rrrFhandle_omp_forbs0     zCxxFunction.handle_omp_forcCsDt|jtjo|jj|j|vo|jj|jv}|t|t  M}|S)aN Check if given for Node can use autoFor syntax. To use auto_for: - iterator should have local scope - yield should not be use - OpenMP pragma should not be use TODO : Yield should block only if it is use in the for loop, not in the whole function. ) rrrrrerrr6rr&)rBrKZauto_forrErErFcan_use_autofors  zCxxFunction.can_use_autoforcCst|jtjs Jtjtjtdtdddtdtgd}t}|j D]}| dd| t |Dq(t ||j}|j|vsL|jj|vrNdS|jj}t|d krZd St|d rbd SdS) z Check if a for loop can use classic C syntax. To use C syntax: - target should not be assign in the loop - range should be use as iterator - order have to be known at compile time builtinsNr)rrr)funcrkeywordscSrrErrrErErFrrz,CxxFunction.can_use_c_for..FTr)rrrrZCallZ Attributerrr~rrrrrsearchrrerrZr3)rBrKZ pattern_rangeZ is_assignedraZnodesrrErErF can_use_c_fors&    zCxxFunction.can_use_c_forcCsd|||S)Nz {0} {1} = {2}rTrBrr iterablerErErFr szCxxFunction.make_assignc sFt|jtjs td|j|j}tfdd|jD}|||jj }|j } |r= |||\}}nJ |rZg}j|jj t|||}||g}n-dt |}jjj|j } ||| ||} t| g}|||| |}t|tjD]} |td| j|qt||S)a Create For representation for Cxx generation. Examples -------- >> for i in range(10): >> ... work ... Becomes >> typename returnable::type __iterX = builtins.range(10); >> ... possible container size reservation ... >> for (auto&& i: __iterX) >> ... the work ... This function also handle assignment for local variables. We can notice that three kind of loop are possible: - Normal for loop on iterator - Autofor loop. - Normal for loop using integer variable iteration Kind of loop used depend on OpenMP, yield use and variable scope. z7Using something other than an identifier as loop targetcr^rEr_r`rArErFrYrbz)CxxFunction.visit_For..z __iter{0}z!pythonic::utils::reserve({0},{1}))rrrrr(rMrrrrerr'rr!rr r%rrUr\rrr r rrr6rZ Comprehensionr) rBrKrrr)rrZautoforr rZasgntcomprErArF visit_Fors@           zCxxFunction.visit_Forcs:|j}fdd|jD}t|t|}||S)zh Create While node for Cxx generation. It is a cxx_loop to handle else clause. cr^rEr_rrArErFrYrbz+CxxFunction.visit_While..)rMtestrr!rr)rBrKr,rrarErArF visit_Whiles  zCxxFunction.visit_WhilecsDfdd|jD}t}|jD] }||qtt||S)Ncr^rEr_rrArErFrY rbz)CxxFunction.visit_Try..)rr}handlersextendrMr"r)rBrKrZexcept_rrErArF visit_Try s  zCxxFunction.visit_Trycsl|jr |jndfdd|jDt|jtjr(fdd|jjDSt|jo/|jj t gS)Ncr^rEr_)rVmrArErFrYrbz3CxxFunction.visit_ExceptHandler..csg|] }t|jtqSrE)r#rr)rVp)rrrErFrYs) rrMrrrrTupleeltsr#rrrrE)rrrBrFvisit_ExceptHandlers  zCxxFunction.visit_ExceptHandlercs|j}fdd|jD}fdd|jD}t|jr*|jjdkr*t|}nt|t||r5t|nd}| ||S)Ncr^rEr_rrArErFrY rbz(CxxFunction.visit_If..cr^rEr_rrArErFrY!rbrt) rMr,rrcr3rrr$rr)rBrKr,rrcrarErArFvisit_Ifs   zCxxFunction.visit_IfcCs$|jo||j}td|pdS)Nz throw {0}r=)excrMrrU)rBrKr7rErErF visit_Raise*szCxxFunction.visit_RaisecCs@||j|jo ||jg}ddd|D}td|S)Nrcss|]}|r|VqdSrGrE)rVZ_frErErFr0sz+CxxFunction.visit_Assert..zpythonic::pythran_assert({0}))rMr,msgrrrU)rBrKparamsZsparamsrErErF visit_Assert.szCxxFunction.visit_AssertcCrrGrrrErErF visit_Import3rzCxxFunction.visit_ImportcCsJd)NFz0should be filtered out by the expand_import passrErrErErFvisit_ImportFrom6zCxxFunction.visit_ImportFromcCs$t||j}|||||SrG)rrMrrrrBrKrarErErF visit_Expr9s zCxxFunction.visit_ExprcCst}|||SrG)rrr?rErErF visit_Pass>s zCxxFunction.visit_PasscCs>|jr|jdr|j|jdtd|jdStdS)zp Generate break statement in most case and goto for orelse clause. See Also : cxx_loop rgoto {0}break)rdrfrrrUrrErErF visit_BreakBszCxxFunction.visit_BreakcCstdS)Ncontinue)rrrErErFvisit_ContinueNr>zCxxFunction.visit_Continuecs,fdd|jD}tt|j}t||S)Ncr^rEr_)rVrrArErFrYSrbz,CxxFunction.visit_BoolOp..)rr)rrr:)rBrKrrrErArF visit_BoolOpRs zCxxFunction.visit_BoolOpcCsl||j}||j}t|rd|jj}t|jr"d|}n t|jr,d|}tt|j ||S)Nz$std::integral_constant{{}}pythonic::types::str({})) rMleftrightr5rUrr2r)rr)rBrKrIrJrErErF visit_BinOpWs      zCxxFunction.visit_BinOpcCs||j}tt|j|SrG)rMoperandr)rr)rBrKrLrErErF visit_UnaryOpds zCxxFunction.visit_UnaryOpcCs2||j}||j}||j}d|||S)Nz(((bool){0}) ? typename __combined::type({1}) : typename __combined::type({2})))rMr,rrcrU)rBrKr,rrcrErErF visit_IfExphs    zCxxFunction.visit_IfExpcs|js dj|Sfdd|jD}j|}t|dkr1djj|j|dSdjj|jd|S) Nz!{}(pythonic::types::empty_list())cr^rEr_rrArErFrYwrbz*CxxFunction.visit_List..rt){0}({1}, pythonic::types::single_value())rz {0}({{{1}}})r) r4rUr\rZrrrqrr)rBrKr4 node_typerErArF visit_Listrs  zCxxFunction.visit_Listcs|js dj|Sfdd|jD}jjj|t|dkr6djjj|dSddfd d |DS) Nz {}(pythonic::types::empty_set())cr^rEr_rrArErFrYrbz)CxxFunction.visit_Set..rtrOr{0}{{{{{1}}}}}rc3s|] }d|VqdS)zstatic_cast<{}::value_type>({})NrTrVelt)rPrErFrs  z(CxxFunction.visit_Set..) r4rUr\rrrZrqrr)rBrKr4rE)rPrBrF visit_Sets zCxxFunction.visit_Setc sp|js dj|Sfdd|jD}fdd|jD}djjj|dddt||DS) Nz!{}(pythonic::types::empty_dict())cr^rEr_rrArErFrYrbz*CxxFunction.visit_Dict..cr^rEr_rrArErFrYrbrRrcs |] \}}d||VqdS)z{{ {0}, {1} }}NrTrVrrrErErFrz)CxxFunction.visit_Dict..)keysrUr\rrrrr[)rBrKrYrrErArF visit_Dicts zCxxFunction.visit_DictcsVfdd|jD}j|}dd|}t|jjjr)d|j|S|S)Ncr^rEr_rSrArErFrYrbz+CxxFunction.visit_Tuple..z pythonic::types::make_tuple({0})rz({}){}) r4r\rUrrrZ CombinedTypesrqr)rBrKr4Z tuple_typer>rErArF visit_Tuples  zCxxFunction.visit_Tuplecs^|j}dd|jD}fdd|jD}t|g|dd||}ddd|DS)NcSsg|]}tt|qSrE)r)rrrErErFrYrz-CxxFunction.visit_Compare..cr^rEr_rrArErFrYrbrz and css |] \}}}|||VqdSrGrE)rVrvryrErErFrsz,CxxFunction.visit_Compare..)rMrIops comparatorsr[r)rBrKrIr]r^Zall_cmpsrErArF visit_Compares zCxxFunction.visit_ComparecsZfdd|jD}|j}|dkr$dd|jdj|dSd|d |S) Ncr^rEr_rrArErFrYrbz*CxxFunction.visit_Call..z&pythonic::builtins::functor::getattr{}z'pythonic::builtins::getattr({}{{}}, {})zpythonic::types::attr::rtrz{}({})r)rrMr#rUrupperr)rBrKrr#rErArF visit_Calls zCxxFunction.visit_CallcCs8|jdurd}nut|jtrt|j}ngt|jtrB|jdddd}t|jdkr;|dd}d |d }nBd |d }n;t|jtrVd t t|jj |jj }n't |jr^d}nt |jro|jdkrjdndd}nt|jtt|jd}||jvrt|jtsJdt t|jt|jfS|S)Npythonic::builtins::None"z\" z\nrt'z\'zpythonic::types::chr('z')zpythonic::types::str("z")z {0}({1}, {2})zpythonic::numpy::nanr+-zpythonic::numpy::infr=z std::integral_constant<%s, %s>{})rrboolrlowerreplacerZcomplexrUr,realimagr8r9reprr-rrZ immediatesr)rBrKretZquotedrErErFvisit_Constants6        zCxxFunction.visit_ConstantcCs0t|\}}dtt|}|s|d7}|S)Nz::z{})r/rmapr1Z isliteral)rBrKobjpathZsattrrErErFvisit_Attributes zCxxFunction.visit_Attributecs4t|tjrtfdd|jDSj|jdkS)Nc3s |] }j|jdkVqdS)rN) range_valueslowrSrArErFrsz+CxxFunction.all_positive..r)rrr3rr4rurvrrErArF all_positives  zCxxFunction.all_positivecs|j}t|jrd|}t|jr*|jjdkr*t|jjtr*d|jj|S|jr<|j}d||St |jrUfdd|jj D}dd ||S|j}d ||S) NrHrzstd::get<{0}>({1})z {1}.fast({0})cr^rEr_rSrArErFrYrbz/CxxFunction.visit_Subscript..z{1}({0}),z{1}[{0}]) rMrr2rUr3slicerrrwr4r4r)rBrKrZslice_ZslicesrErArFvisit_Subscripts"            zCxxFunction.visit_SubscriptcCs<|j|jvr t|jS|j|jvrdt|jSt|jS)Nz{0}())rerr1Zglobal_declarationsrUrrErErF visit_Names    zCxxFunction.visit_NamecCsg}dD]}t||}|r||nd}||q|jdus*t|jrE|jjdkrE||jr9||jr9d}nd}| |d|dSdj |S)N)rir`rrbrtz-pythonic::types::fast_contiguous_slice({},{})z(pythonic::types::contiguous_slice({},{})rz pythonic::types::slice({},{},{})) rrMrrr3rrwrir`rU)rBrKrZfieldZnfieldrrrErErF visit_Slices    zCxxFunction.visit_SlicerG):rNrOrPrQr@rrrrMrrrrrrrrrrrrrrr r!r'r rir+r-r0r5r6r8r;r<r=r@rArDrFrGrKrMrNrQrUrZr[r_rarprtrwrzr{r|rRrErErCrFrsp   E51K" H           rcsdeZdZdZdZdZddZfddZdd Zd d Z d d Z ddZ ddZ fddZ ZS)rZ__generator_stateZ__generator_valueZthat_is_all_folkscGs|SrGrE)rBrKrrrErErFr#szCxxGenerator.process_localscs2g|_ddt|t|D|_tt||S)NcSs(i|]\}}|d|dd|fqS)rtzyield_point{0}rT)rVrrrErErFr*s(z.)extra_declarationsrrrr r?rrrrCrErFr&s z(CxxGenerator.prepare_functiondef_contextcsd_|}|\}}}|}|\}}}} } dt|j} d| |r.dd|nd} jr<|tt j |t dt t dd gtg} tt t d| gtd g}|r|rgt|rgt}|tt|d| |||td dd gd d|Dtt t ddgtt dgtt t d| dgdttt jgtt t d| dgtt dtd| gtt t d| dgttd| gg}tt t d| d| g|}|}|dt dt jdddtjd d!d"Dtjd#dt||Dfd$dj Dd%dj!Dt d&| t jg}fd'dj"|d(D}t#t d|rTd)| d|n| d*t#t |$d+g}t#t |$dg}%|||}tt&| ||||| d,|}t|t|}tt'|| d-|||||tg}t'|| d.t|j||}tt||ttd/| d|g}tt&d0||}t&t|j|| | g|}||g||gfS)1NFz__generator__{0}rrrr=zreturn result_type()rnextz: pythonic::yielder() {}z : {0} {{ }}zpythonic::yielder()cSsg|]}d|qS)z{0}({0})rTrrErErFrYVsz2CxxGenerator.visit_FunctionDef..rz operator++znext()ztypename {0}::result_typez operator*rz(pythonic::types::generator_iterator<{0}>Zbeginz/pythonic::types::generator_iterator<{0}>(*this)endz*pythonic::types::generator_iterator<{0}>()z {0}::nextrzswitch({0}) {{ {1} }} csrV)zcase {0}: goto {1};NrT)rVnumwhererErErFrrXz1CxxGenerator.visit_FunctionDef..cSrs)NrrErurErErFrwrxz0CxxGenerator.visit_FunctionDef..rycSs g|] \}}td||qSrrrU)rVZftfarErErFrYcs.g|]}tdjj||qSr)rrUr\rrqrrrErFrYs  cSs g|] \}}td||qSrrrWrErErFrYrztypename {0}::result_type {1}crrErrrrErFrYrrtz{0}<{1}>iteratorZ value_typezpythonic::yielderrrz{0}({1})r)(returnsrrrUr1rrrrrFinalStatementrrrrrrrr}rrr StateValuer]r StateHolderr{r rrjrr[rr}r\rrqrrr)rBrKrrrrrrrrrZ next_nameZinstanciated_next_nameZnext_declarationZnext_constructorsZ next_iteratorZnext_signatureZ next_bodyZ next_membersZextern_typedefsZiterator_typedefZresult_typedefrZ next_structZnext_definitionrrrZtopstruct_typerrErrFr/s         !        zCxxGenerator.visit_FunctionDefcCs*d|_ttdtjtdtjgS)NTz{0} = -1rB)rrrrUrrrrrErErFrszCxxGenerator.visit_Returnc CsX|j|\}}dddtttj|tdtj| |j t d|g DS)Nr=css|]}|VqdSrGrErrErErFrsz+CxxGenerator.visit_Yield..z {0} = {1}z{0}:) r rrrrrrrUrrMrrrq)rBrKrZlabelrErErF visit_Yields     zCxxGenerator.visit_Yieldcs@|j}fdd|jD}d|}t||}||S)Ncr^rEr_rrArErFrYrbz-CxxGenerator.visit_Assign..r)rMrrrrr)rBrKrrrrarErArFrs    zCxxGenerator.visit_AssigncCsdS)zx TODO : Yield should block only if it is use in the for loop, not in the whole function. FrErrErErFr!szCxxGenerator.can_use_autoforcs$|j||ftt|d||Sr<)r}rr?rr r(rCrErFr szCxxGenerator.make_assign)rNrOrPrrrrrrrrrr!r rRrErErCrFrs  & rcs0eZdZdZfddZddZddZZS)Cxxah Produces a C++ representation of the AST. >>> import gast as ast, pythran.passmanager as passmanager, os >>> node = ast.parse("def foo(): return 'hello world'") >>> pm = passmanager.PassManager('test') >>> r = pm.dump(Cxx, node) >>> print(str(r).replace(os.sep, '/')) #include #include namespace __pythran_test { struct foo { typedef void callable; typedef void pure; struct type { typedef typename pythonic::returnable::type result_type; } ; inline typename type::result_type operator()() const; ; } ; inline typename foo::type::result_type foo::operator()() const { return pythonic::types::str("hello world"); } } c s(d|_tt|tttttt t t dSr) r>r?rr@r rr.rr r r r rArCrErFr@s z Cxx.__init__c stj}dd|D}|dd|D7}ttdfdd|jD}|r*t|nggf\}}dd||D}ttjj |}t ||g_ dS)z Build a compilation unit. cSs0g|]}ttjjddgtt|RdqS)pythonicZinclude.hpprosrsrrqr1rrErErFrY&s z$Cxx.visit_Module..cSs.g|]}ttjjdgtt|RdqS)rrrrrErErFrY)s&Nc3s|]}|VqdSrGr_r`rArErFr,rz#Cxx.visit_Module..cSsg|] }|D]}|qqSrErE)rVZlsrrErErFrY0s) r{Z dependenciesr}filterrr[rr+Z passmanagerZ module_namerr>) rBrKZ header_depsZheadersZ decls_n_defnsZdeclsZdefnsZnsbodynsrErArF visit_Module"s  zCxx.visit_ModulecCs&|t|}|r tnt|}||SrG)rrrrrM)rBrKr ZvisitorrErErFr4s  zCxx.visit_FunctionDef)rNrOrPrQr@rrrRrErErCrFrs  !rrG)NN)UrQZpythran.analysesrrrrrrrr r r r r Zpythran.cxxgenrrrrrrrrrrrrrrrrrrr r!r"r#r$r%Zpythran.openmpr&Zpythran.passmanagerr'Zpythran.syntaxr(Zpythran.tablesr)r*r+Zpythran.types.conversionr,r-Zpythran.types.typesr.Z pythran.utilsr/r0r1r2r3r4r5Zpythranr6r7Zmathr8r9Zgastrr functoolsr:rHr;r]rirjrrrZ NodeVisitorrrrrErErErFsX         0%  j^