)g; ddZddlZddlZddlZddlZddlZddlmZmZm Z dZ dZ dZ dZ dZ dZ d Z d Z d Z d Z d Z dZdZdZiZ GddeZedefiZ GddeZejdkrdZejje_ee_dZ dZ!GddeZ"dZ#dZ$ej%dZ&ej%dZ'ej%d ej(Z)d!Z*ej%d"ej(Z+d#Z,d,d%Z-d&Z.ddd'ggggd$df d(Z/d)Z0eZ1 Gd*d+eZ2dS)-z6 Tasks represent atomic operations such as processes. N)UtilsLogsErrors z def f(tsk): env = tsk.env gen = tsk.generator bld = gen.bld cwdx = tsk.get_cwd() p = env.get_flat tsk.last_cmd = cmd = ''' %s ''' % s return tsk.exec_command(cmd, cwd=cwdx, env=env.env or None) a 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) z def f(tsk): super(tsk.__class__, tsk).sig_vars() 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()) c"eZdZdZfdZxZS)store_task_typez 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. ctt|||||j}|dkr'|dkr"t |ddrt |j|j\}}tj |j|_ |j|_ d|_||_ tt|j|z|_|j|jrt#|j}|r||_n8t |ddr'd|jvrtj |j |_ |t |dt(|<dSdSdS)NevilTaskrun_strrunhcoderegister)superr__init____name__getattr compile_funrshellrh_cmdr orig_run_strrlistsetvarssortcompile_sig_varssig_vars__dict__classes)clsnamebasesdictfdvarsfun __class__s %/git_repos/midimsg-lv2/waflib/Task.pyrzstore_task_type.__init__hsE&&tUD999 $ V^^ c9d##%S[#)44JQ CK((CI{CCKCGC5())**CHHMMOOO x CH % %S clUD!!%'S\*A*A CG$$CI.173 G$$T***+^)r __module__ __qualname____doc__r __classcell__)r0s@r1rrasB 111111111r2rrc4eZdZdZgZ dZ dZ dZ gZ gZ gZ gZ e j Z dZ dZ dZ dZ dZdZdZdZd Zd Zd Zd Zd ZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*dZ+dZ,dZ-d Z.d!Z/d"Z0d#Z1 d$Z2d%Z3d&Z4d#S)'ra{ Task objects represents actions to perform such as commands to execute by calling the `run` method. Detecting when to execute a task occurs in the method :py:meth:`waflib.Task.Task.runnable_status`. Detecting which tasks to execute is performed through a hash value returned by :py:meth:`waflib.Task.Task.signature`. The task signature is persistent from build to build. FGREENr)hasrun generatorenvinputsoutputs dep_nodes run_afterct|_ |d|_n#t$r ||_YnwxYw|d|_ g|_ g|_ g|_ t|_ dS)Nr:r;) NOT_RUNr9r:KeyErrorr;r<r=r>r"r?)selfkkws r1rz Task.__init__s$+{O4>> 4>>>Y$(P$+P$,T$.-55$.::s 00cV||kSNpriorityrCothers r1__lt__z Task.__lt__ 5>>++ ++r2cV||kSrGrHrJs r1__le__z Task.__le__ ENN,, ,,r2cV||kSrGrHrJs r1__gt__z Task.__gt__rMr2cV||kSrGrHrJs r1__ge__z Task.__ge__rPr2cH|jj}t|ddpt|d|j}t |t rYt j|r|j |}n|jj |}|S)zO :return: current working directory :rtype: :py:class:`waflib.Node.Node` cwdN) r:bldrbldnode isinstancestrospathisabsroot make_node)rCrWrets r1get_cwdz Task.get_cwds #eT""Fgc5#+&F&F#S-gmmC- (  S ! !CC .  ' ' , ,C *r2c|}d|vr|dd}d|vr|dd}||ks d|vsd|vsd|vrd|z}|S) z Surround a process argument by quotes so that a list of arguments can be written to a file :param x: flag :type x: string :return: quoted flag :rtype: string \\\"z\"  'z"%s")replace)rCxolds r1 quote_flagzTask.quote_flagsp # QYYyyv1AXXyye1AXXTQYY#(( z1 (r2cN|j|jzt|jdd fS)zw Priority of execution; the higher, the earlier :return: the priority value :rtype: a tuple of numeric values tg_idx_countr)weight prio_orderrr:rCs r1rIz Task.prioritys* + '74>>ST+U+U)U VVr2cB|dgfd|ddDfS)z Splits a list of process commands into the executable part and its list of arguments :return: a tuple containing the executable first and then the rest of arguments :rtype: tuple rc:g|]}|S)rl).0rjrCs r1 z&Task.split_argfile.. s%999AT__Q''999r2rNrt)rCcmds` r1 split_argfilezTask.split_argfiles3 q6(9999QRR999 ::r2c d|vr||d<t|dr |j|d<|jjrt |dp|jjp tjx}|d<t|jjtr |jjn(tj |jj|d<t|dr |j |d<t|dr |j|d<t|tsOtjr"t#t%|dkr"nt#|dkr ||\}} t)j\}}tj|d |tj|t2jrt3jd |||jjj|d |zgzfi| tj|S#t@$rYSwxYw# tj|w#t@$rYwwxYwxYw|jjj|fi|S) a Wrapper for :py:meth:`waflib.Context.Context.exec_command`. This version set the current working directory (``build.variant_dir``), applies PATH settings (if self.env.PATH is provided), and can run long commands through a temporary ``@argfile``. :param cmd: process command to execute :type cmd: list of string (best) or string (process will use a shell) :return: the return code :rtype: int Optional parameters: #. cwd: current working directory (Node or string) #. stdout: set to None to prevent waf from capturing the process standard output #. stderr: set to None to prevent waf from capturing the process standard error #. timeout: timeout value (Python 3) rVtimeoutr;PATHstdoutstderri i@ z zargfile: @%r -> %r@)!rahasattrrzr;r{r,getr[environrYrZpathsepjoinr|r}ris_win32lenreprrxtempfilemkstempwriteencodecloserverbosedebugr:rW exec_commandremoveOSError)rCrwrEr;argsfdtmps r1rzTask.exec_commandsp& "||~~2e9 T9 <2i= X]e"&&--E48<E2:FFF3E",TX]C"@"@dbjooVZV^VcFdFd3v; T8+2h< T8+2h< C  5U^53tCyy>>T#9#9#9QTUXQYQY\bQbQb!!#&&93   ""IRHRT""))++,,,HRLLL |1 Z$c4000 *4>  *3#)+< C C C C Ys^^^^     T  Ys^^^^     T  *$.  )# 4 4 4 44sC=B$I"H77 III. II. I+(I.*I++I.c |jjj|=n#t$rYnwxYw |}|r||_t|_n | t|_nx#tj $rYngt$r'tj|_t"|_Yn8wxYw#t$r'tj|_t"|_YnwxYw|jtkr?|jr: |jjj|=dS#t$rYdSwxYwdSdS)zd Runs the task and handles errors :return: 0 or None if everything is fine :rtype: integer N)r:rW task_sigsuidrBrerr_codeCRASHEDr9post_runSUCCESSrWafError Exception traceback format_excerr_msg EXCEPTIONscanimp_sigsrCr`s r1processz Task.processEs} ~#DHHJJ// 4 3  DMDKK ]]___T[[ ?    T (**T\T[[[ &((4<4;;;$ [G   #DHHJJ///    DD sG$' 44C#BC-CC.C98C9$D:: EEc|jjjdkrdS|}|r|jr|j}nt }|jjjdkrJt jj}t jj}| |tj d||ddS| |dddddSdS)z1Writes the execution status on the context loggerrNr)stream terminatorc1c2)extra)rrr) r:rW progress_bardisplayloggerrcolors cursor_off cursor_oninfosysr})rCrWsrrrs r1 log_displayzTask.log_displayns ^$)) 6 llnn! A j ZFF F n%**  B  B KKCJRrRTUUKVVVVV KKrB??K@@@@@ A Ar2c f tj|j}tjj}|jjj fd}|jjjdkr/|jj| j ||S|jjjdkrt|jjj } d d|j D}n#t$rd}YnwxYw d d|jD}n#t$rd}YnwxYwd j d |d |d |d |d St|}|sdS j }t!t|} d| | fz} |} | r| dz } | ||| |||fzS)zi Returns an execution status for the console, the progress bar, or the IDE output. :rtype: string cFjjz SrG) processedreadyqsize)mastersr1curzTask.display..curs  V\//11 11r2rr,cg|] }|j Srtr*runs r1rvz Task.display..s111QV111r2rcg|] }|j Srtrrs r1rvz Task.display..s222QV222r2z|Total z |Current z|Inputs z |Outputs z|Time z| Nz[%%%dd/%%%dd] %%s%%s%%s%%s rf)rrcolorNORMALr:rWproducerr progress_linetotalrZtimerrr<AttributeErrorr=rkeyword) rCcol1col2relainsoutsrrrfsrErs @r1rz Task.displays TZ $  $ >  &&22222 ^$)) .  * *3355&,d K KK ^$)) T^  % & &3 8811T[111 2 2CC    CCC  8822T\222 3 3DD  DDDDJLLLRURURWRWRWRWY\Y\Y\^b^b^bdgdgdg hh $ii!  $ ,% #e**oo!%A." ||~~" 92 ssuueRq$/ //s$:$C C.-C.2$D D&%D&ct|jt|jt|jt|j|jj|jfS)z Identifies a task type for all the constraints relevant for the scheduler: precedence, file production :return: a hash value :rtype: string )tuplebeforeafterext_inext_outr0rrrqs r1hash_constraintszTask.hash_constraintssJ   eDJ//t{1C1CU4 task in z failed with exit status z failedz -> missing files in z/ -> %r canceled because of missing dependencieszinvalid status for task in ) rrrr:rr9rrrMISSINGCANCELED)rCmsgr*s r1 format_errorzTask.format_errors<  \66ttWT:r::: ;33 53  , ,$ T9d##D , ; D D?CttTT JJ {g3<@DD$--QTQT UU 3333(,cc 22223 {g)-ss 33 {h ;d BB26t{{ CCs4BBBc|j|sgSt|tr|j|}n|}ttrfd|DSg}|D],}|||-|S)a 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'] cg|]}|zSrtrt)rurjrs r1rvzTask.colon..s   q37   r2)r;rYrZextendappend)rCvar1var2itlstyrs @r1colonz Task.colons #  9c  22 2S    B    3 qJJsOOOJJqMMMM :r2cz|jj}|jrU|ds|js9|jd}||jS|js|js |jjSt|jdkr9|jd}||jSd d|jD}d d|jD}|jrd}nd}|jjd |||S) zstring to display to the userlibprogramrrrfcfg|].}||j/Srt path_fromctx launch_noderuas r1rvz Task.__str__..s2LLL1akk!%"3"3"5"566LLLr2cfg|].}||j/Srtrrs r1rvz Task.__str__..s2MMM1akk!%"3"3"5"566MMMr2 -> rr) r0rr=endswithr<rrrrr)rCr*nodesrc_strtgt_strseps r1__str__z Task.__str__s7  $ \2 mm&''2t{2 <?D >>$(..00 1 11 +"" . !! +a.4 ..--// 0 00 HHLL LLL M M' HHMM MMM N N' \ 33 3000''33 HHr2c|jj}|drdSt|jdkrt|jdkrdS|js |jrdSdSdS)z4Display keyword used to prettify the console outputsrLinkingr CompilingCreatingRunning Processing)r0rrrr<r=)rCr*s r1rz Task.keywordsw  $ ]]%&& )s4<00A55 +  l : 9 r2c  dd|jD}dd|jD}nX#t$rKdd|jD}dd|jD}YnwxYwddt |z|jjd|d |d gS) zfor debugging purposesrcg|] }|j Srtrrurjs r1rvz!Task.__repr__..s///a16///r2cg|] }|j Srtrrs r1rvz!Task.__repr__..s111qAF111r2c,g|]}t|SrtrZrs r1rvz!Task.__repr__..s///a3q66///r2c,g|]}t|Srtrrs r1rvz!Task.__repr__..s111qCFF111r2rz {task %r: rfr})rr<r=ridr0r)rCrrs r1__repr__z Task.__repr__s3 //4;/// 0 03 ((11DL111 2 244 333 //4;/// 0 03 ((11DL111 2 24443 "RXX-t~/FSRXZ^`cd e eesAA AB B c |jS#t$rwtj|jj}|j}|j|jzD]}||  | |_|jcYSwxYw)a 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 ) uid_rrmd5r0rupdater<r=abspathdigestrCmuprjs r1rzTask.uids" )  y())1 2 K$, &qBqyy{{OOOOxxzz49 ) s A>B  B ct|tr|xj|z c_dS|j|dS)zj Appends the nodes to the *inputs* list :param inp: input nodes :type inp: node or list of nodes N)rYr!r<r)rCinps r1 set_inputszTask.set_inputs7sFT;;#;;;;;cr2ct|tr|xj|z c_dS|j|dS)zl Appends the nodes to the *outputs* list :param out: output nodes :type out: node or list of nodes N)rYr!r=r)rCouts r1 set_outputszTask.set_outputsCsFT<<3<<<<<sr2cht|tsJ|j|dS)a 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)rYrr?add)rCtasks r1 set_run_afterzTask.set_run_afterOs6 D$  .Tr2c |jS#t$rYnwxYwtj|j|_|||jr? | n)#tj $r| cYSwxYw|j x}|_|S)a 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 ) cache_sigrrrrrsig_explicit_depsr&rsig_implicit_depsr TaskRescan signaturerrs r1r%zTask.signature\s* . 4 9TZ $&--/// Y   >>  (# *s 'A<<#B"!B"cH|jj}|jdkrtS|jD]+}|js t cS|jtkr tcS, | }n#tj $r t cYSwxYw| } |j |}n,#t$rtjd|t"cYSwxYw||krtjd|t"S|jD]}|j|}|stjd|t"cS||krtjd|t"cS|stjd|t"cS|jrt"ptS)z 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 rzHtask: task %r must run: it was never run before or the task code changedz2task: task %r must run: the task signature changedz7task: task %r must run: an output node has no signaturezCtask: task %r must run: an output node was produced by another taskz5task: task %r must run: an output node does not exist)r:rW is_installSKIP_MEr?r9 ASK_LATERSKIPPED CANCEL_MEr%r TaskNotReadyrrrBrrRUN_MEr= node_sigsrexists always_run)rCrWtnew_sigkeyprev_sigrsigs r1runnable_statuszTask.runnable_statuss #^a > >a (  7    ^^  77     #mC 88 :XZ^___ === :BDIII =l  d   4 3 JH$OOO MMM SjjJTVZ[[[ MMM ++--JFMMM MMM / $f 00s$A((BB B''&CCc|jj}|jD]s}|sAt|_d|z|_tj |j| |j |<t| |j | <|js |`dS#t $rYdSwxYwdS)z Called after successful execution to record that the task has run by updating the entry in :py:attr:`waflib.Build.BuildContext.task_sigs`. z-> missing file: %rN)r:rWr=r/rr9rrrrrr.r%r keep_last_cmdrr)rCrWrs r1rz Task.post_runs #l$$d ++--(DK(4<<>>9DL /$, ' ''3="nn..#-        DD   s>C CCc|jj}|jj}|j|jzD]}|| |jr|j}|j|jzD]n} ||}n#t$rYwxYw|D]M} |}n*#t$rt|dr |}YnwxYw||NmdSdS)z 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. __call__N) r:rWrrr<r> get_bld_sigdeps_manr=rBrr)rCrWupdrjadditional_depsdvs r1r"zTask.sig_explicit_depss1 #  # ; 'a3q}} \ \? K$, &   q  QQ  X   --//aa  J   133q SVVVV       s$(A11 A>=A>B$CCc|jjfd|j|jzD}|jt j|dS)a 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. chg|].}|jj|/Srt)is_bldrr.)rurrWs r1rvz(Task.sig_deep_inputs..s9hhhZ^ZeZeZgZghs}T* +hhhr2N)r:rWr<r>rrrh_list)rCrrWs @r1sig_deep_inputszTask.sig_deep_inputssU, #hhhht~9Uhhh#&-- S!!"""""r2c|jj|j|j}|j|dS)a1 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. N)r:rW hash_env_varsr;r#rr)rCr5s r1r&z Task.sig_varss< ((49==#&--r2Nc|jj}|}|j|g}|r ||kr|Sn#t j$rt$r|j |gD]N}| s8| s$ |j j |j=>#t$rYJwxYwOYnwxYw|j|=t jd|\|j |<|j|<t&jr-t'jd||j ||j| ||j|<dS#t$r\|j |gD],}| st'jd||-wxYw)a Used by :py:meth:`waflib.Task.Task.signature`; it hashes node signatures obtained by scanning for dependencies (:py:meth:`waflib.Task.Task.scan`). The exception :py:class:`waflib.Errors.TaskRescan` is thrown when a file has changed. In this case, the method :py:meth:`waflib.Task.Task.signature` is called once again, and return here to call :py:meth:`waflib.Task.Task.scan` and searching for dependencies. rescanz(deps: scanner for %s: %r; unresolved: %rzPDependency %r for %r is missing: check the task declaration and the build order!N)r:rWrrrcompute_sig_implicit_depsrr,EnvironmentError node_depsrCr/parentchildrenr*rBr$rraw_depsrrrwarn)rCrWr3prevrjrDs r1r#zTask.sig_implicit_deps!s* #  #   #r " "$ %  t--//// [0          ]  txxzz2 . .   HHJJ qxxzz  8 QV $ $     t     |C  8 $ $$-1IIKK)3=s|C( \g:8$ c@RTWT`adTefff 55773<    M  dhhjj" - -llq 88::l Yacdfjkkk  sCAA0C2 CC2 C+(C2*C++C21C22FA&G6c"|jj}||jjj|gD]}|| |j S)z Used by :py:meth:`waflib.Task.Task.sig_implicit_deps` for computing the actual hash of the :py:class:`waflib.Node.Node` returned by the scanner. :return: a hash value for the implicit dependencies :rtype: string or bytes ) rrare_implicit_nodes_readyr:rWrLrrr;r)rCr=rDs r1rJzTask.compute_sig_implicit_depsRs{  #!!! >  ' + +DHHJJ ; ;a3q}} r2c|jj} |j}n#t$r ix|_}YnwxYw ||j}n5#t $r(ix}||j<|jD]}|jD]}|||<YnwxYwd}|j | gD](}||vr"|j ||d})|r%|j D]}|j stjddSdS)z For each node returned by the scanner, see if there is a task that creates it, and infer the build order This has a low performance impact on null builds (1.86s->1.66s) thanks to caching (28s->1.86s) FTz not readyN)r:rWdct_implicit_nodesr current_grouprB cur_tasksr=rLrrr?rr9rr,)rCrWcachedcttskrjmodifieds r1rSzTask.are_implicit_nodes_readydsl #'  !55 '''$&&3EEE' s !33 $&&3s !ms [SVV ( =  TXXZZ , ,a3hhNs1vH ,n,,s :,  { + ++,,,,,s,, >/A0/A0)5rr3r4r5r#r0rrrrrrrSIG_NILrr8ro tree_weightrp __slots__rrLrOrRrTrarlrIrxrrrrrrrrrr rrrrr%r6rr"rEr&rr#rJrSrtr2r1rrs xV ; L > A I H J M[;;;,,,,---,,,---       $WWW;;;454545l' ' ' RAAA&'0'0'0RDDD6BIII*   fff6         * * * X212121h   &   :###4 "/ / / b$ , , , , ,r2ricj |jS#t$rtj|jjdd}|j}|j|j zD]3}|| dd4| |_|jcYSwxYw)Nzlatin-1xmlcharrefreplace) rrrrr0rrrr<r=rrrs r1rrs )  y(// ;NOOPP1 2 K$, &;;qBqyy{{)%899::::xxzz49 ) s B&B21B2ctj}||jD]}|||jvrdS|jj||jvrdS|jj||jvrdSdS)aC 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` rr)rto_listrrr0rrr)t1t2rbrDs r1 is_beforeres = '")    Q''"*   !!LWWRX.... LWWRY////  r2c>tjt}tjt}|D]q}|jD]}||||jD]}||||jD]}|||rt||}|D]-}||D]"}|j ||#.dS)z 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) r defaultdictr"r<rr>r=keys intersectionr?r)tasksrrrjrlinksrDs r1set_file_constraintsrls#  # Q 8aq6::a==== ;aq6::a==== 9a7;;q>>>> SXXZZ % %diikk 2 2 Q q6a;d1gr2c6eZdZdZdZdZeedZdS) TaskGroupz Wrap nxm task order constraints into a single object to prevent the creation of large list/set objects This is an optimization c0||_||_d|_dS)NF)rQnextdone)rCrQrps r1rzTaskGroup.__init__s$)$)$)))r2cD|jD]}|js tcStSrG)rQr9rAr)rCrDs r1 get_hasrunzTaskGroup.get_hasruns0 9a ( NNN .r2N)rr3r4r5rrspropertyr9rtr2r1rnrnsI   (:t $ $r2rncPtjt}|D]1}|}|||2t|}t |}t|D]}|||d}t|dz|D]}|||d} t|| r|} |} nt| |r|} |} nA||| } ||| } t | dkst | dkr | D]}|j | tt| t| } | D]}|j | dS)z 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` rrrN)rrgr!rrrhrrangerer?rrnr"r) rj cstr_groupsrjhrhmaxiircjrdrbgroups r1set_precedence_constraintsr~s && Q! a. [       D  ++Q47A" Q  aDGQ2B  A AA"b  A AA 471471 !ffqjjCFFQJJ [ c!ffc!ff % %E [__U+r2c6i}t|||dS)z 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-)exec)cdcs r1funexrs a 3r2z"(?P\w+)|(?P\|)|(?P&)z^(SRC|TGT)\W+.*?$zM(?P\\)|(?P\$\$)|(?P\$\{(?P\w+)(?P.*?)\})c g fd}t||p|}g fd fd}g}|j} D]\}}|dkr|r|d|z|d)|dkr|r|d|z@|d L|r&|d r ||d d }|dkrd }nu|dkrd}nlt|rd|dd z}nDt|rd|dd z}n ||d ddvrd|z}|d|d|d |dr7t ||d d }|d|d|dW||}  | || u ||d|z|rdd|z}nd}t||fz} tj d| t|  fS) zH Creates a compiled function to execute a process through a sub-shell c|j}|drdS|drdS|dr+|d|dfdSdS) Ndollar$ backslashrdsubstvarcodez%s)r}r)matchgextrs r1replzcompile_fun_shell..replsu k!Qx[[ #q~~ &qzz;;%!!F))$%%% $ r2c>|vr|dSdSrGrrjr.s r1add_dvarz#compile_fun_shell..add_dvar%&e^^<<?????^r2c|drdS|drdS|d}|d|zSNandz and orz or rzenv[%r]r}rrjrs r1replcz compile_fun_shell..replc)WWWU^^ 'wwt}} &wwu~~1 8A;;; a-r2SRCz tsk.inputs%sz1" ".join([a.path_from(cwdx) for a in tsk.inputs])TGTz tsk.outputs%sz2" ".join([a.path_from(cwdx) for a in tsk.outputs]):rN'[a.path_from(cwdx) for a in tsk.inputs]([a.path_from(cwdx) for a in tsk.outputs][tsk.inputs%s]r[tsk.outputs%s]rZgenrW%rz" ".join(tsk.colon(, z))?zp(z) if (z ) else ""zp('%s')z%% (%s) z, r action: %s)reg_actsubr startswithre_novarrre_condrCOMPILE_TEMPLATE_SHELLrrstrip splitlinesr)linerrparmapprmethrexprcallrrr.rs @@@r1compile_fun_shellrs         D$'4        {&&[c4E\\ =CC;<<<< e|| >C$C<====  ooc HSMMM QRRAEzz 2QQ e 3QQ    AabbE !QQ    QqrrU "QQ Xa[[[ "1"*** (aCCaaa01111  ;;ud122h ' 'DCC333-....S$$ D HTNNNCIIII 8C===3y3 y~~d++ ,$$ $tTl*L!''))..00111 q5r2z[(?P\s+)|(?P\$\{(?P\w+)(?P.*?)\})|(?P([^$ \t\n\r\f\v]|\$\$)+)c g}g d}|j} fd fd}t|D]T}|drd}|dr7|d|dddzn|d r|d }|d }|d kr|r|d |znt|dng|dkr|r|d|znO|dnB|r&|dr ||dd}|d krd}nu|dkrd}nlt |rd |ddz}nDt |rd|ddz}n ||dddvrd|z}|d|d|dn|dr6t ||dd}|d|d|dn9||}  | |d| zn|d |z ||rd!|d"d|d#d} |d#=| |d#<d$}Vd%|D}td& |z} tj d'| t!|  fS)(zH Creates a compiled function to execute a process without a sub-shell Fc>|vr|dSdSrGrrs r1rz%compile_fun_noshell..add_dvarprr2c|drdS|drdS|d}|d|zSrrrs r1rz"compile_fun_noshell..replctrr2spacetextz[%r]z$$rrrrrrrrrrrrNrrrz tsk.colon(r)rz to_list(env[z] if (z ) else [])zgen.to_list(%s)zto_list(env[%r])zmerge(r r Tcg|]}d|zS)zlst.extend(%s)rtrs r1rvz'compile_fun_noshell..s***1***r2 r)rreg_act_noshellfinditerr}rirrrrrCOMPILE_TEMPLATE_NOSHELLrrrrrr)rbufmergerrrrrrrrr/rr.s @@r1compile_fun_noshellrgs    z       " "4 ( (66QWWW0 5 wwv-3v''c2223333www+ 3 ''&//4 Ull 4S D !!!!S 23333 u  5S T !""""S 34444  s# Xc]]] abbQ U 3aa u** 4aa ..   QqrrU "aa ..   ae #aahqkkk 2A2+ + + !8qSSQQQ '((((   # KKtABBx ( (TSSsssDDD 9::::c44 T Xd^^^S T !""""CS !!! HSMMM GGGSWWW -3 2w 3r7 %%**c***&++c"2"22L#))++0022333 sUr2Fct|trN|ddks2|ddks|ddkrd}njg}g|D]Z}t|tr.t||\}}||z }|E|[fd}||fS|rt |St |S)a 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 z&&Tc4D]}||}|r|cSdSrGrt)rrjr`funs_lsts r1 composed_funz!compile_fun..composed_funs: q !D''C  ZZZ $r2)rYrZfindrrrr)rr dvars_lstrjr/r.rrs @r1rrs&tS! YYs^^a499S>>A--411D1D 5) ( aCQ&&JC I OOC OOA y   # 4  T " ""r2cg}t|D]&}|dddvr|d|z'|r*ttd|zSdS)a 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 Nrrzbuf.append(%s)r)sortedrrCOMPILE_TEMPLATE_SIG_VARSr)r#rrjs r1r%r%sx,  ,,$$QrrU###::"###= (6;;s+;+;; < << r2r8c |pg|||| d} t|tst|tr|| d<n|| d<tt|tf| } | t |<|rt j|| _|rt j|| _ |rt j|| _ |rt j|| _ | S)a Returns a new task subclass with the function ``run`` compiled from the line given. :param func: method run :type func: string or function :param vars: list of variables to hash :type vars: list of string :param color: color to use :type color: string :param shell: when *func* is a string, enable/disable the use of the shell :type shell: bool :param scan: method scan :type scan: function :rtype: :py:class:`waflib.Task.Task` )r#rr*rrrr) rYrZrtyperr(rrbrrrr) r*funcr#rrrrrrrparamsr)s r1 task_factoryrs$ *"       tSZe44&&-tDzz$(( %}V$$#* ' g&&#+ %}V$$#* #mE""#) r2cd}||_|S)zJ Task class decorator to enable rebuilds on input files task signatures cnt|t|dSrG)rr"rErqs r1r"z&deep_inputs..sig_explicit_deps7s0tr2)r")r)r"s r1 deep_inputsr3s + r2c*eZdZdZdZdZdZdZdS) TaskSemaphorea0 Task semaphores provide a simple and efficient way of throttling the amount of a particular task to run concurrently. The throttling value is capped by the amount of maximum jobs, so for example, a `TaskSemaphore(10)` has no effect in a `-j2` build. Task semaphores are typically specified on the task class level:: class compile(waflib.Task.Task): semaphore = waflib.Task.TaskSemaphore(2) run_str = 'touch ${TGT}' Task semaphores are meant to be used by the build scheduler in the main thread, so there are no guarantees of thread safety. c`||_t|_t|_dS)zD :param num: maximum value of concurrent tasks :type num: int N)numr"lockingwaiting)rCrs r1rzTaskSemaphore.__init__Ps% $($,$,,,r2c<t|j|jkS)z?Returns True if this semaphore cannot be acquired by more tasks)rrrrqs r1 is_lockedzTaskSemaphore.is_lockedYs T\  dh &&r2c|rtd|jz|j|dS)z Mark the semaphore as used by the given task (not re-entrant). :param tsk: task object :type tsk: :py:class:`waflib.Task.Task` :raises: :py:class:`IndexError` in case the resource is already acquired zCannot lock more %rN)r IndexErrorrrrCrZs r1acquirezTaskSemaphore.acquire]sH ^^: )DL8 9 99,3r2c:|j|dS)z Mark the semaphore as unused by the given task. :param tsk: task object :type tsk: :py:class:`waflib.Task.Task` :raises: :py:class:`KeyError` in case the resource is not acquired by the task N)rrrs r1releasezTaskSemaphore.releaseis ,cr2N)rr3r4r5rrrrrtr2r1rr@sZ'''   r2r)F)3r5r[rerrrwaflibrrrrArrrrr*rr)r(r-r+rrrr(rrobjectrr hexversionrrerlrnr~rcompilerrMrrrrrr%rrTaskBaserrtr2r1rs" ('''''''''''''''''''&&&&&&&&&& # D 8 1 > * (  * +   A *   1 1 1 1 1d 1 1 1Dvy"--h~ ,~ ,~ ,~ ,~ ,4~ ,~ ,~ ,~>I   x    8.%%%%%%%%((((T    "*9 : : 2:* + + "*egigk l lPPPd"*{}~BCCSSSj+#+#+#+#Z   <!t72rZ\dfnsz~* * * * X    A11111F11111r2