!^c @s"dZddlZddlZddlZddlZddlZddlmZmZm Z dZ dZ dZ dZ dZd Zd ZdZd Zd Zd ZdZdZdZiZdefdYZedefiZdefdYZejdkr,dZejje_ee_ndZ dZ!defdYZ"dZ#dZ$ej%dZ&ej%dZ'ej%d ej(Z)d!Z*ej%d"ej(Z+d#Z,e-d$Z.d%Z/e0e0d&gggge-e0d' Z1d(Z2eZ3d)efd*YZ4dS(+s6 Tasks represent atomic operations such as processes. iN(tUtilstLogstErrorsiiiiiii iiis def f(tsk): env = tsk.env gen = tsk.generator bld = gen.bld cwdx = tsk.get_cwd() p = env.get_flat def to_list(xx): if isinstance(xx, str): return [xx] return xx tsk.last_cmd = cmd = ''' %s ''' % s return tsk.exec_command(cmd, cwd=cwdx, env=env.env or None) s def f(tsk): env = tsk.env gen = tsk.generator bld = gen.bld cwdx = tsk.get_cwd() def to_list(xx): if isinstance(xx, str): return [xx] return xx def merge(lst1, lst2): if lst1 and lst2: return lst1[:-1] + [lst1[-1] + lst2[0]] + lst2[1:] return lst1 + lst2 lst = [] %s if '' in lst: lst = [x for x in lst if x] tsk.last_cmd = lst return tsk.exec_command(lst, cwd=cwdx, env=env.env or None) s def f(tsk): sig = tsk.generator.bld.hash_env_vars(tsk.env, tsk.vars) tsk.m.update(sig) env = tsk.env gen = tsk.generator bld = gen.bld cwdx = tsk.get_cwd() p = env.get_flat buf = [] %s tsk.m.update(repr(buf).encode()) tstore_task_typecBseZdZdZRS(s Metaclass: store the task classes into the dict pointed by the class attribute 'register' which defaults to :py:const:`waflib.Task.classes`, The attribute 'run_str' is compiled into a method 'run' bound to the task class. cCsLtt|j||||j}|dkrH|dkrHt|ddrt|j|j\}}t j |j|_ |j|_ d|_||_ tt|j||_|jj|jr/t|j}|r||_qq/n9t|ddr/d|jkr/t j |j |_ n|t|dt||j|d %rt@N(#RBthasattrROR'RPRtgetR<tenvironR:R;tpathseptjoinRQRRRtis_win32tsumtlenR tTrueRNttempfiletmkstemptwritetencodetcloseRtverbosetdebugR&R8t exec_commandtremovetOSError( R.RMR0R'targttoo_longtargstfdttmp((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRes:  2@ 8  %  cCs(y|jjj|j=Wntk r-nXy|j}Wn)tk ritj|_ t |_ nrX|r||_ t |_ nVy|jWn<tjk rn2tk rtj|_ t |_ n Xt|_ |j tkr$|jr$y|jjj|j=Wq$tk r q$XndS(sd Runs the task and handles errors :return: 0 or None if everything is fine :rtype: integer N(R&R8t task_sigstuidR-Rt Exceptiont tracebackt format_excterr_msgt EXCEPTIONR%terr_codetCRASHEDtpost_runRtWafErrortSUCCESStscantimp_sigs(R.RA((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytprocessOs2          cCs|jjjdkrdS|j}|r|jr@|j}nt}|jjjdkrtjj}tjj}|j |dit j d6dd6|d6|d 6q|j |didd6dd6dd 6ndS( s1Writes the execution status on the context loggeriNitextratstreamtt terminatortc1tc2( R&R8t progress_bartdisplaytloggerRtcolorst cursor_offt cursor_ontinfotsysRR(R.R8tsRRR((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyt log_displayxs     5c stj|j}tjj}|jjjfd}|jjjdkrs|jjj|j ||S|jjjdkrFt |jjj }y,dj g|j D]}|j^q}Wntk rd}nXy,dj g|jD]}|j^q}Wntk r(d}nXdj ||||fSt |}|s\d Sj } tt | }d||f} |j} | r| d7} n| || | |||fS( si Returns an execution status for the console, the progress bar, or the IDE output. :rtype: string csjjjS(N(t processedtreadytqsize((tmaster(s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytcursiit,R~s3|Total %s|Current %s|Inputs %s|Outputs %s|Time %s| s[%%%dd/%%%dd] %%s%%s%%s%%s RDN(RRtcolortNORMALR&R8tproducerRt progress_linettotalR;ttimerRYR(RtAttributeErrorR)RR\tkeyword( R.tcol1tcol2RtelatntinstoutsRRtfsR0((Rs./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRs6 ",  ,      cCsCt|jt|jt|jt|j|jj|jfS(s Identifies a task type for all the constraints relevant for the scheduler: precedence, file production :return: a hash value :rtype: string (ttupletbeforetaftertext_intext_outt __class__R R(R.((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pythash_constraintsscCstjr(d|t|ddf}nd}t|jdd}t|dd r\|jS|jssd||fS|jtkryd||j|fSWqt k rd ||fSXnE|jt krd ||fS|jt krd |Sd ||jfSd S(sU Returns an error message to display the build failure reasons :rtype: string s: %r %rtlast_cmdR~s* (run with -v to display more information)RRrs/task in %r was not executed for some reason: %rs+ -> task in %r failed with exit status %r%ss -> task in %r failed%ss -> missing files in %r%ss/ -> %r canceled because of missing dependenciess!invalid status for task in %r: %rN( RRcR R&RRrR%RuRtRtMISSINGtCANCELED(R.tmsgR((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyt format_errors$   cCs|j|}|sgSt|tr6|j|}n|}t|trfg|D]}||^qRSg}x(|D] }|j||j|qsW|SdS(s Enable scriptlet expressions of the form ${FOO_ST:FOO} If the first variable (FOO_ST) is empty, then an empty list is returned The results will be slightly different if FOO_ST is a list, for example:: env.FOO = ['p1', 'p2'] env.FOO_ST = '-I%s' # ${FOO_ST:FOO} returns ['-Ip1', '-Ip2'] env.FOO_ST = ['-a', '-b'] # ${FOO_ST:FOO} returns ['-a', '-b', 'p1', '-a', '-b', 'p2'] N(R'R:R;textendtappend(R.tvar1tvar2RltitRGtlstty((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytcolons   cCsH|jj}|jrT|jd s.|j rT|jd}|j|jjSn|jpc|jsp|jjSt|jdkr|jd}|j|jjSdj g|jD]}|j|jj^q}dj g|jD]}|j|jj^q}|jr(d}nd}d|jj|||fS( sstring to display to the usertlibtprogramiiRDs -> R~s %s: %s%s%s(RR( RR R)tendswithR(t path_fromtctxt launch_nodeR\RY(R.Rtnodetatsrc_strttgt_strtsep((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyt__str__s      77  cCsn|jj}|jd rdSt|jdkrMt|jdkrMdS|jsj|jrcdSdSndS( s4Display keyword used to prettify the console outputsRRtLinkingit CompilingtCreatingtRunningt Processing(RR(RR RR\R(R)(R.R((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRs *  cCsyTdjg|jD]}|j^q}djg|jD]}|j^q;}Wngtk rdjg|jD]}t|^qt}djg|jD]}t|^q}nXdjdt||jjd|d|dgS(sfor debugging purposesRR~s {task %r: RDs -> t}( RYR(RR)RR;tidRR (R.RGRR((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyt__repr__s(, +/cCsy |jSWnmtk rztj|jj}|j}x(|j|jD]}||j qJW|j |_|jSXdS(s Returns an identifier used to determine if tasks are up-to-date. Since the identifier will be stored between executions, it must be: - unique for a task: no two tasks return the same value (for a given build context) - the same for a given task instance By default, the node paths, the class name, and the function are used as inputs to compute a hash. The pointer to the object (python built-in 'id') will change between build executions, and must be avoided in such hashes. :return: hash value :rtype: string N( tuid_RRtmd5RR tupdateR(R)tabspathtdigest(R.tmtupRG((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRn&s   cCs5t|tr!|j|7_n|jj|dS(sj Appends the nodes to the *inputs* list :param inp: input nodes :type inp: node or list of nodes N(R:RR(R(R.tinp((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyt set_inputsAscCs5t|tr!|j|7_n|jj|dS(sl Appends the nodes to the *outputs* list :param out: output nodes :type out: node or list of nodes N(R:RR)R(R.tout((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyt set_outputsMscCs)t|tst|jj|dS(s Run this task only after the given *task*. Calling this method from :py:meth:`waflib.Task.Task.runnable_status` may cause build deadlocks; see :py:meth:`waflib.Tools.fc.fc.runnable_status` for details. :param task: task :type task: :py:class:`waflib.Task.Task` N(R:RtAssertionErrorR+tadd(R.ttask((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyt set_run_afterYs cCsy |jSWntk rnXtj|j|_|j|j|jry|j Wqt j k r||j SXn|jj }|_|S(s Task signatures are stored between build executions, they are use to track the changes made to the input nodes (not to the outputs!). The signature hashes data from various sources: * explicit dependencies: files listed in the inputs (list of node objects) :py:meth:`waflib.Task.Task.sig_explicit_deps` * implicit dependencies: list of nodes returned by scanner methods (when present) :py:meth:`waflib.Task.Task.sig_implicit_deps` * hashed data: variables/values read from task.vars/task.env :py:meth:`waflib.Task.Task.sig_vars` If the signature is expected to give a different result, clear the cache kept in ``self.cache_sig``:: from waflib import Task class cls(Task.Task): def signature(self): sig = super(Task.Task, self).signature() delattr(self, 'cache_sig') return super(Task.Task, self).signature() :return: the signature value :rtype: string or bytes (t cache_sigRRRRRtsig_explicit_depsRRytsig_implicit_depsRt TaskRescant signatureR(R.RA((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRfs     cCsp|jj}|jdkrtSx1|jD]&}|js<tS|jtkr)tSq)Wy|j }Wnt j k rztSX|j }y|j |}Wn"tk rtjd|tSX||krtjd|tSx}|jD]r}|jj|}|stjd|tS||kr9tjd|tS|jstjd|tSqW|jrltpotS(s Returns the Task status :return: a task state in :py:const:`waflib.Task.RUN_ME`, :py:const:`waflib.Task.SKIP_ME`, :py:const:`waflib.Task.CANCEL_ME` or :py:const:`waflib.Task.ASK_LATER`. :rtype: int isHtask: task %r must run: it was never run before or the task code changeds2task: task %r must run: the task signature changeds7task: task %r must run: an output node has no signaturesCtask: task %r must run: an output node was produced by another tasks5task: task %r must run: an output node does not exist(R&R8t is_installtSKIP_MER+R%t ASK_LATERtSKIPPEDt CANCEL_MERRt TaskNotReadyRnRmR-RRdtRUN_MER)t node_sigsRVtexistst always_run(R.R8tttnew_sigtkeytprev_sigRtsig((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytrunnable_statussB       cCs|jj}xa|jD]V}|jsYt|_d|j|_tj |jn|j |j | missing file: %rN(R&R8R)RRR%RRrRRwRnRRRmt keep_last_cmdRR(R.R8R((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRvs      cCs|jj}|jj}x(|j|jD]}||jq)W|jr|j}x|j|jD]}y||}Wnt k rqfnXxW|D]O}y|j}Wn,t k rt |dr|}qnX||qWqfWndS(s Used by :py:meth:`waflib.Task.Task.signature`; it hashes :py:attr:`waflib.Task.Task.inputs` and :py:attr:`waflib.Task.Task.dep_nodes` signatures. t__call__N( R&R8RRR(R*t get_bld_sigtdeps_manR)R-RRU(R.R8tupdRGtadditional_depstdtv((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRs$       cCsf|jj}g|j|jD]&}|jr|j|j|^q}|jjt j |dS(s Enable rebuilds on input files task signatures. Not used by default. Example: hashes of output programs can be unchanged after being re-linked, despite the libraries being different. This method can thus prevent stale unit test results (waf_unit_test.py). Hashing input file timestamps is another possibility for the implementation. This may cause unnecessary rebuilds when input tasks are frequently executed. Here is an implementation example:: lst = [] for node in self.inputs + self.dep_nodes: st = os.stat(node.abspath()) lst.append(st.st_mtime) lst.append(st.st_size) self.m.update(Utils.h_list(lst)) The downside of the implementation is that it absolutely requires all build directory files to be declared within the current build. N( R&R8R(R*tis_bldRmRRRRth_list(R.R8RR((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytsig_deep_inputss =cCs2|jjj|j|j}|jj|dS(s Used by :py:meth:`waflib.Task.Task.signature`; it hashes :py:attr:`waflib.Task.Task.env` variables/values When overriding this method, and if scriptlet expressions are used, make sure to follow the code in :py:meth:`waflib.Task.Task.compile_sig_vars` to enable dependencies on scriptlet results. This method may be replaced on subclasses by the metaclass to force dependencies on scriptlet code. N(R&R8t hash_env_varsR'RRR(R.R((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRscCs|jj}|j}|jj|g}|ry||jkrL|SWntjk rfn|tk rxl|j j|jgD]K}|j r|j ry|j j |j=Wqtk rqXqqWnX|j|=tjdn|j\|j |<|j|1.66s) thanks to caching (28s->1.86s) s not readyN(R&R8tdct_implicit_nodesRt current_groupR-t cur_tasksR)tFalseRRVRnR+RR]R%RR(R.R8tcachetdctttskRGtmodified((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRps*    "   (R%R&R'R(R)R*R+N(6R R"R#RRRRRRRRRRtSIG_NILRRRKt tree_weightRLt __slots__R R3R4R5R6RBRIR1RNReR{RRRRRRRRRnRRRRRRvRRRRRyRRR(((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRs`         < )  )  !    , 4     1 icCsy |jSWntk rtj|jjjdd}|j}x4|j|j D]"}||j jddqVW|j |_|jSXdS(Nslatin-1txmlcharrefreplace( RRRRRR RaRR(R)RR(R.RRRG((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRns  !  cCs~tj}x0||jD]}|||jkrdSqW|jj||jkr[dS|jj||jkrzdSdS(sC Returns a non-zero value if task t1 is to be executed before task t2:: t1.ext_out = '.h' t2.ext_in = '.h' t2.after = ['t1'] t1.before = ['t2'] waflib.Task.is_before(t1, t2) # True :param t1: Task object :type t1: :py:class:`waflib.Task.Task` :param t2: Task object :type t2: :py:class:`waflib.Task.Task` ii(Rtto_listRRRR RR(tt1tt2RR/((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyt is_befores cCstjt}tjt}x}|D]u}x"|jD]}||j|q5Wx"|jD]}||j|qZWx"|jD]}||j|qWq%Wt|jj|j}x7|D]/}x&||D]}|j j ||qWqWdS(s Updates the ``run_after`` attribute of all tasks based on the task inputs and outputs :param tasks: tasks :type tasks: list of :py:class:`waflib.Task.Task` N( Rt defaultdictRR(RR*R)tkeyst intersectionR+R(ttasksRRRGRtlinksR/((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytset_file_constraintss ! t TaskGroupcBs/eZdZdZdZeedZRS(s Wrap nxm task order constraints into a single object to prevent the creation of large list/set objects This is an optimization cCs||_||_t|_dS(N(RtnextRtdone(R.RR((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyR s  cCs%x|jD]}|js tSq WtS(N(RR%R,Rx(R.R/((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyt get_hasruns N(R R"R#R RtpropertyRR%(((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRs  c Cstjt}x+|D]#}|j}||j|qWt|j}t|}x5t|D]'}|||d}x t|d|D]}|||d} t|| r|} |} n!t| |r|} |} nq||| } ||| } t| dks+t| dkrOx]| D]}|j j | q2Wqt t | t | } x| D]}|j j | qqWqWqhWdS(s Updates the ``run_after`` attribute of all tasks based on the after/before/ext_out/ext_in attributes :param tasks: tasks :type tasks: list of :py:class:`waflib.Task.Task` iiiN(RRRRRRR\trangeRR+RRRR( Rt cstr_groupsRGthRtmaxitiRtjRRtbtgroup((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytset_precedence_constraintss2     $  cBsi}||U|dS(s Compiles a scriptlet expression into a Python function :param c: function to compile :type c: string :return: the function 'f' declared in the input string :rtype: function R((tctdc((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytfunexs s"(?P\w+)|(?P\|)|(?P&)s^(SRC|TGT)\W+.*?$sM(?P\\)|(?P\$\$)|(?P\$\{(?P\w+)(?P.*?)\})c sgfd}tj||p*|}gfdfd}g}|j}xD]\}}|dkr|r|d|q|dqg|dkr|r|d|q|d qg|r|jd r||d }|dkrd }n||dkr&d }ngtj|rFd|d}nGtj|rfd|d}n'||d dkrd|}n|d||fq|jdrtj||d }|d||fqd||f} | || qg||d|qgW|r?ddj|}nd}t||f} t j d| j j t | fS(sH Creates a compiled function to execute a process through a sub-shell cs\|j}|drdS|dr)dS|drXj|d|dfdSdS( Ntdollart$t backslashs\\tsubsttvartcodes%s(R%RR(tmatchtg(textr(s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytrepl%s    cs |krj|ndS(N(R(RG(R (s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytadd_dvar1s csK|jdrdS|jdr&dS|jd}|d|SdS(Ntands and tors or R.senv[%r](R%(RRG(R4(s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytreplc5s tSRCs tsk.inputs%ss1" ".join([a.path_from(cwdx) for a in tsk.inputs])tTGTs tsk.outputs%ss2" ".join([a.path_from(cwdx) for a in tsk.outputs])t:is'[a.path_from(cwdx) for a in tsk.inputs]s([a.path_from(cwdx) for a in tsk.outputs]s[tsk.inputs%s]is[tsk.outputs%s]R tgenR8s%rs" ".join(tsk.colon(%r, %s))t?sp(%r) if (%s) else ""s%s%ssp('%s')s%% (%s) s, R~s action: %s(R R;R8(treg_acttsubRt startswithtre_novarR0tre_condRYtCOMPILE_TEMPLATE_SHELLRRdtstript splitlinesR)( tlineR3R7tparmtappR.tmethRtexprtcallR'((R4R R2s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytcompile_fun_shell s^                  s[(?P\s+)|(?P\$\{(?P\w+)(?P.*?)\})|(?P([^$ \t\n\r\f\v]|\$\$)+)c sg}gt}|j}fdfd}xtj|D]n}|jdrjt}qIn|jdr|d|jdjddn|jdr|jd }|jd }|d kr|r|d |q||d q|dkr,|r|d|q||dq|rd|jdr||d}|d krjd }n||dkrd}ngtj|rd |d}nGtj|rd|d}n'||d d$krd|}n|d||fq||jdr9t j ||d}|d||fq|d||f} | |d| q|d||n|rd|d|d f} |d =| |d R]tCOMPILE_TEMPLATE_NOSHELLRYRRdRCRDR)( REtbuftmergeRGR7RR.R/RIRJRlRGR!((R4R s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pytcompile_fun_noshellssp  &                cst|trZ|jddksN|jddksN|jddkrt}qng}gxY|D]Q}t|trt||\}}||7}j|qmj|qmWfd}||fS|rt|St|SdS(s Parses a string expression such as '${CC} ${SRC} -o ${TGT}' and returns a pair containing: * The function created (compiled) for use as :py:meth:`waflib.Task.Task.run` * The list of variables that must cause rebuilds when *env* data is modified for example:: from waflib.Task import compile_fun compile_fun('cxx', '${CXX} -o ${TGT[0]} ${SRC} -I ${SRC[0].parent.bldpath()}') def build(bld): bld(source='wscript', rule='echo "foo\${SRC[0].name}\bar"') The env variables (CXX, ..) on the task must not hold dicts so as to preserve a consistent order. The reserved keywords ``TGT`` and ``SRC`` represent the task input and output nodes ts&&cs+x$D]}||}|r|SqWdS(N(R(RRGRA(tfuns_lst(s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyt composed_funs   N(R:R;tfindR]RRRKRS(RERt dvars_lstRGR!R RW((RVs./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRs ?     cCsbg}x8t|D]*}|d dkr|jd|qqW|r^ttdj|SdS( s This method produces a sig_vars method suitable for subclasses that provide scriptlet code in their run_str code. If no such method can be created, this method returns None. The purpose of the sig_vars method returned is to ensures that rebuilds occur whenever the contents of the expression changes. This is the case B below:: import time # case A: regular variables tg = bld(rule='echo ${FOO}') tg.env.FOO = '%s' % time.time() # case B bld(rule='echo ${gen.foo}', foo='%s' % time.time()) :param vars: env variables such as CXXFLAGS or gen.foo :type vars: list of string :return: A sig_vars method relevant for dependencies if adequate, else None :rtype: A function, or None in most cases iR R;R8sbuf.append(%s)s (R R;R8N(tsortedRR)tCOMPILE_TEMPLATE_SIG_VARSRYR(RRQRG((s./git_repos/PolyLV2/poly_mclk_in/waflib/Task.pyRsR$c Csi|p gd6|d6|d6|d6| d6} t|tsMt|trZ|| dsX<"      *  R U - $,