a ”$a>šã @sŠdZddlZddlZddlZddlZddlZddlmZmZm Z dZ dZ dZ dZ dZdZd Zd Zd Zd Zd ZdZdZdZiZGdd„deƒZedefiƒZGdd„deƒZejdkrÌdd„Zejje_ee_dd„Z dd„Z!Gdd„deƒZ"dd „Z#d!d"„Z$e %d#¡Z&e %d$¡Z'e %d%ej(¡Z)d&d'„Z*e %d(ej(¡Z+d)d*„Z,d7d,d-„Z-d.d/„Z.ddd0ggggd+df d1d2„Z/d3d4„Z0eZ1Gd5d6„d6eƒZ2dS)8z6 Tasks represent atomic operations such as processes. éN)ÚUtilsÚLogsÚErrorséééééé éÿÿÿÿéþÿÿÿéýÿÿÿéüÿÿÿa 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) 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): 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()) cs eZdZdZ‡fdd„Z‡ZS)Ú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. csÜtt|ƒ |||¡|j}|dkrØ|dkrØt|ddƒr¤t|j|jƒ\}}t  |j¡|_ |j|_ d|_||_ t t|j|ƒƒ|_|j ¡|jrÈt|jƒ}|rÈ||_n$t|ddƒrÈd|jvrÈt  |j ¡|_ |t|dtƒ|<dS)NÚevilÚTaskÚrun_strÚrunÚhcodeÚregister)ÚsuperrÚ__init__Ú__name__ÚgetattrÚ compile_funrÚshellrZh_cmdrZ orig_run_strrÚlistÚsetÚvarsÚsortÚcompile_sig_varsÚsig_varsÚ__dict__Úclasses)ÚclsÚnameÚbasesÚdictÚfÚdvarsÚfun©Ú __class__©úf/home/jack/SDK/ZBT-AX3000-OpenWrt-21.02/build_dir/hostpkg/samba-4.14.12/third_party/waf/waflib/Task.pyrls$   zstore_task_type.__init__)rÚ __module__Ú __qualname__Ú__doc__rÚ __classcell__r-r-r+r.resrrc@sNeZdZdZgZdZdZdZgZgZ gZ gZ e j ZdZdZdZdZdZdd„Zdd „Zd d „Zd d „Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Z d d!„Z!d"d#„Z"d$d%„Z#d&d'„Z$d(d)„Z%d*d+„Z&d,d-„Z'd.d/„Z(d0d1„Z)d2d3„Z*d4d5„Z+d6d7„Z,d8d9„Z-d:d;„Z.dd?„Z0d@Z1dAdB„Z2dCdD„Z3dEdF„Z4d@S)Gra{ 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. FÚGREENr)ÚhasrunÚ generatorÚenvÚinputsÚoutputsÚ dep_nodesÚ run_aftercOsVt|_z|d|_Wnty,||_Yn0|d|_g|_g|_g|_tƒ|_ dS)Nr5r6) ÚNOT_RUNr4r5ÚKeyErrorr6r7r8r9rr:)ÚselfÚkÚkwr-r-r.rÂs   z Task.__init__cCs| ¡| ¡kS©N©Úpriority©r=Úotherr-r-r.Ú__lt__Øsz Task.__lt__cCs| ¡| ¡kSr@rArCr-r-r.Ú__le__Úsz Task.__le__cCs| ¡| ¡kSr@rArCr-r-r.Ú__gt__Üsz Task.__gt__cCs| ¡| ¡kSr@rArCr-r-r.Ú__ge__Þsz Task.__ge__cCsX|jj}t|ddƒp t|d|jƒ}t|tƒrTtj |¡rF|j   |¡}n|jj  |¡}|S)zO :return: current working directory :rtype: :py:class:`waflib.Node.Node` ÚcwdN) r5ÚbldrÚbldnodeÚ isinstanceÚstrÚosÚpathÚisabsÚrootÚ make_node)r=rJÚretr-r-r.Úget_cwdás  z Task.get_cwdcCsX|}d|vr| dd¡}d|vr,| dd¡}||ksLd|vsLd|vsLd|vrTd|}|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)r=ÚxÚoldr-r-r.Ú quote_flagïs    zTask.quote_flagcCs|j|jt|jddƒ fS)zw Priority of execution; the higher, the earlier :return: the priority value :rtype: a tuple of numeric values Z tg_idx_countr)ÚweightÚ prio_orderrr5©r=r-r-r.rBsz Task.prioritycs$|dg‡fdd„|dd…DƒfS)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 rcsg|]}ˆ |¡‘qSr-)r^©Ú.0r\rar-r.Ú óz&Task.split_argfile..rNr-)r=Úcmdr-rar.Ú split_argfile szTask.split_argfilecKsòd|vr| ¡|d<t|dƒr(|j|d<|jjr~t| d¡pH|jjpHtjƒ}|d<t |jjt ƒrj|jjntj   |jj¡|d<t|dƒr’|j |d<t|dƒr¦|j|d<t |t ƒsÜtjrØtdd„|Dƒƒt|ƒd k}n t|ƒd k}|rÜt|d d ƒrÜ| |¡\}}z®t ¡\}}t |d   |¡ ¡¡t |¡tjrJt d||¡|jjj|d|gfi|¤ŽWzt  |¡WSt!yŒYS0Szt  |¡Wnt!y²Yn0n&zt  |¡Wnt!yØYn00|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) rIÚtimeoutr6ÚPATHÚstdoutÚstderrcSsg|] }t|ƒ‘qSr-)Úlen)rcÚargr-r-r.rd8rez%Task.exec_command..i i@ Zallow_argsfileTz zargfile: @%r -> %rú@)"rTÚhasattrrhr6rir'ÚgetrNÚenvironrLrMÚpathsepÚjoinrjrkrZis_win32ÚsumrlrrgÚtempfileZmkstempÚwriteÚencodeÚcloserÚverboseÚdebugr5rJÚ exec_commandÚremoveÚOSError)r=rfr?r6Ztoo_longÚargsÚfdÚtmpr-r-r.r{sL   $*          úüzTask.exec_commandcCsîz|jjj| ¡=Wnty&Yn0z | ¡}Wn"tyVt ¡|_ t |_ Yn\0|rj||_ t |_ nHz | ¡Wn4tjyŠYn(tyªt ¡|_ t |_ Yn0t|_ |j tkrê|jrêz|jjj| ¡=WntyèYn0dS)zd Runs the task and handles errors :return: 0 or None if everything is fine :rtype: integer N)r5rJÚ task_sigsÚuidr<rÚ ExceptionÚ tracebackZ format_excÚerr_msgÚ EXCEPTIONr4Úerr_codeÚCRASHEDÚpost_runrÚWafErrorÚSUCCESSÚscanÚimp_sigs©r=rSr-r-r.ÚprocessOs2           z Task.processcCs„|jjjdkrdS| ¡}|r€|jr,|j}nt}|jjjdkrjtjj}tjj}|j |t j d||dœdn|j |ddddœddS)z1Writes the execution status on the context loggerrNrÚ)ÚstreamÚ terminatorÚc1Úc2)Úextra)r’r“r”) r5rJÚ progress_barÚdisplayÚloggerrÚcolorsZ cursor_offZ cursor_onÚinfoÚsysrk)r=rJÚsr˜r“r”r-r-r.Ú log_displayxszTask.log_displayc s@t |j¡}tjj}|jjj‰‡fdd„}|jjjdkrP|jj |ƒˆj ||¡S|jjjdkræt |jjj ƒ}zd  dd„|j Dƒ¡}Wntyœd}Yn0zd  d d„|jDƒ¡}WntyÎd}Yn0d ˆj |ƒ|||fSt |ƒ}|söd Sˆj }tt |ƒƒ} d | | f} | ¡} | r*| d 7} | |ƒ|| |||fS)zi Returns an execution status for the console, the progress bar, or the IDE output. :rtype: string csˆjˆj ¡Sr@)Ú processedZreadyZqsizer-©Zmasterr-r.Úcur•szTask.display..currrú,cSsg|] }|j‘qSr-©r%©rcÚnr-r-r.rdŸrez Task.display..rcSsg|] }|j‘qSr-r¢r£r-r-r.rd£rez3|Total %s|Current %s|Inputs %s|Outputs %s|Time %s| Nz[%%%dd/%%%dd] %%s%%s%%s%%s rX)rr™ÚcolorZNORMALr5rJZproducerr–Z progress_lineÚtotalrMZtimerrsr7ÚAttributeErrorr8rlÚkeyword) r=Zcol1Zcol2r ZelaÚinsÚoutsrœr¦r¤Zfsr?r-rŸr.r—‹s6         z Task.displaycCs.t|jƒt|jƒt|jƒt|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 )ÚtupleÚbeforeÚafterÚext_inÚext_outr,rrrar-r-r.Úhash_constraints´szTask.hash_constraintscCsÊtjrd|t|ddƒf}nd}t|jddƒ}t|ddƒr@|jS|jsRd||fS|jtkrzd ||j|fWStyŒd ||fYS0n6|jt kr¦d ||fS|jt kr¸d |Sd ||jfSdS)zU Returns an error message to display the build failure reasons :rtype: string z: %r %rÚlast_cmdrz* (run with -v to display more information)r%r…Nz/task in %r was not executed for some reason: %rz+ -> task in %r failed with exit status %r%sz -> task in %r failed%sz -> missing files in %r%sz/ -> %r canceled because of missing dependenciesz!invalid status for task in %r: %r) rryrr5r…r4rˆr‡r§ÚMISSINGÚCANCELED)r=Úmsgr%r-r-r.Ú format_error½s$       zTask.format_errorcsr|j|‰ˆsgSt|tƒr(|j|}n|}tˆtƒrH‡fdd„|DƒSg}|D]}| ˆ¡| |¡qP|SdS)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'] csg|] }ˆ|‘qSr-r-rb©r€r-r.rdñrezTask.colon..N)r6rLrMÚextendÚappend)r=Zvar1Zvar2ÚitÚlstÚyr-r¶r.ÚcolonØs      z Task.coloncCsÄ|jj}|jr8| d¡s|js8|jd}| |j ¡¡S|jsL|jsL|jjSt|jƒdkrt|jd}| |j ¡¡Sd  dd„|jDƒ¡}d  dd„|jDƒ¡}|jr¬d}nd }d |jj|||fS) zstring to display to the user©ÚlibÚprogramrrrXcSsg|]}| |j ¡¡‘qSr-©Ú path_fromÚctxÚ launch_node©rcÚar-r-r.rdrez Task.__str__..cSsg|]}| |j ¡¡‘qSr-rÀrÄr-r-r.rdreú -> rz %s: %s%s%s) r,rr8Úendswithr7rÁrÂrÃrlrs)r=r%ÚnodeZsrc_strZtgt_strÚsepr-r-r.Ú__str__ùs    z Task.__str__cCsN|jj}| d¡rdSt|jƒdkr6t|jƒdkr6dS|jsJ|jrFdSdSdS)z4Display keyword used to prettify the console outputsr½ZLinkingrZ CompilingZCreatingZRunningZ Processing)r,rrÇrlr7r8)r=r%r-r-r.r¨s z Task.keywordc Cs”z0d dd„|jDƒ¡}d dd„|jDƒ¡}Wn>tynd dd„|jDƒ¡}d dd„|jDƒ¡}Yn0d dt|ƒ|jjd |d |d g¡S) zfor debugging purposesr¡cSsg|] }|j‘qSr-r¢rbr-r-r.rdrez!Task.__repr__..cSsg|] }|j‘qSr-r¢rbr-r-r.rd recSsg|] }t|ƒ‘qSr-©rMrbr-r-r.rd"recSsg|] }t|ƒ‘qSr-rËrbr-r-r.rd#rerz {task %r: rXrÆú})rsr7r8r§Úidr,r)r=r©rªr-r-r.Ú__repr__s z Task.__repr__cCsbz|jWSty\t |jj¡}|j}|j|jD]}||  ¡ƒq6|  ¡|_|jYS0dS)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 N) Úuid_r§rÚmd5r,rÚupdater7r8ÚabspathÚdigest©r=ÚmZupr\r-r-r.r‚&s  zTask.uidcCs*t|tƒr|j|7_n |j |¡dS)zj Appends the nodes to the *inputs* list :param inp: input nodes :type inp: node or list of nodes N)rLrr7r¸)r=Zinpr-r-r.Ú set_inputsAs zTask.set_inputscCs*t|tƒr|j|7_n |j |¡dS)zl Appends the nodes to the *outputs* list :param out: output nodes :type out: node or list of nodes N)rLrr8r¸)r=Úoutr-r-r.Ú set_outputsMs zTask.set_outputscCst|tƒsJ‚|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)rLrr:Úadd)r=Útaskr-r-r.Ú set_run_afterYs zTask.set_run_aftercCs~z|jWStyYn0t |j¡|_| ¡| ¡|jrjz |  ¡Wnt j yh|  ¡YS0|j  ¡}|_|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 )Z cache_sigr§rrÐrrÕÚsig_explicit_depsr!rŒÚsig_implicit_depsrÚ TaskRescanÚ signaturerÓrŽr-r-r.rßfs  zTask.signaturecCs6|jj}|jdkrtS|jD]$}|js.tS|jtkrtSqz |  ¡}Wnt j yftYS0|  ¡}z|j |}Wn"ty t d|¡tYS0||krºt d|¡tS|jD]b}|j |¡}|sèt d|¡tS||krt d|¡tS| ¡sÀt d|¡tSqÀ|jr2tp4tS)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)r5rJZ is_installÚSKIP_MEr:r4Ú ASK_LATERÚSKIPPEDÚ CANCEL_MErßrÚ TaskNotReadyr‚rr<rrzÚRUN_MEr8Ú node_sigsrpÚexistsÚ always_run)r=rJÚtZnew_sigÚkeyZprev_sigrÈÚsigr-r-r.Úrunnable_status’sB                 zTask.runnable_statuscCs‚|jj}|jD]:}| ¡s:t|_d| ¡|_t  |j¡‚|  ¡|j |<q|  ¡|j |  ¡<|js~z|`Wnty|Yn0dS)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)r5rJr8rçr²r4rÒr…rrŠr‚rærßrÚ keep_last_cmdr±r§)r=rJrÈr-r-r.r‰Æs   z Task.post_runc Cs¶|jj}|jj}|j|jD]}|| ¡ƒq|jr²|j}|j|jD]j}z ||}Wnt ylYqFYn0|D]<}z | ¡}Wn"t y¤t |dƒr |ƒ}Yn0||ƒqrqFdS)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) r5rJrÕrÑr7r9Ú get_bld_sigZdeps_manr8r<r§ro)r=rJÚupdr\Zadditional_depsÚdÚvr-r-r.rÜÙs$       zTask.sig_explicit_depscs8|jj‰‡fdd„|j|jDƒ}|j t |¡¡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. cs$g|]}| ¡rˆjˆj|‘qSr-)Úis_bldrræ)rcrÈ©rJr-r.rd rez(Task.sig_deep_inputs..N)r5rJr7r9rÕrÑrZh_list)r=rºr-rôr.Úsig_deep_inputsöszTask.sig_deep_inputscCs$|jj |j|j¡}|j |¡dS)a˜ 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)r5rJZ hash_env_varsr6rrÕrÑ)r=rër-r-r.r!sz Task.sig_varsNc CsX|jj}| ¡}|j |g¡}|r¾z|| ¡kr6|WSWnrtjyN‚Yn^tyª|j  | ¡g¡D]8}|  ¡sl|  ¡slz|j j |j=Wqlty¢Yql0qlYn0|j|=t d¡‚| ¡\|j |<|j|<tjrøt d||j ||j|¡z| ¡|j|<WnHtyR|j  | ¡g¡D]}|  ¡s,t d||¡q,‚Yn0dS)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. Zrescanz(deps: scanner for %s: %r; unresolved: %rzPDependency %r for %r is missing: check the task declaration and the build order!N)r5rJr‚rrpÚcompute_sig_implicit_depsrräÚEnvironmentErrorÚ node_depsrórçÚparentÚchildrenr%r<rÞrŒZraw_depsrryrzÚwarn)r=rJrêÚprevr\r>r-r-r.rÝ-s8       zTask.sig_implicit_depscCsB|jj}| ¡|jjj | ¡g¡D]}|| ¡ƒq&|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 ) rÕrÑÚare_implicit_nodes_readyr5rJrørpr‚rïrÓ)r=rðr>r-r-r.rö^s zTask.compute_sig_implicit_depscCsÜ|jj}z |j}Wnty.i|_}Yn0z||j}Wn@ty~i}||j<|jD]}|jD] }|||<qjq`Yn0d}|j  |  ¡g¡D] }||vr–|j   ||¡d}q–|rØ|j D]}|j sÂt d¡‚qÂdS)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)r5rJZdct_implicit_nodesr§Z current_groupr<Z cur_tasksr8rørpr‚r:rÙr4rrä)r=rJÚcacheZdctÚtskr\Zmodifiedr-r-r.rýps*      zTask.are_implicit_nodes_ready)5rr/r0r1rrèrr¥r®r¯r¬r­rZSIG_NILrrír_Z tree_weightr`Ú __slots__rrErFrGrHrTr^rBrgr{rrr—r°rµr¼rÊr¨rÎr‚rÖrØrÛrßrìr‰rÜrõr!rŒrÝrörýr-r-r-r.rŠs`  <)) !    ,4 1ric Csrz|jWStylt |jj dd¡¡}|j}|j|j D]}||  ¡ dd¡ƒq>|  ¡|_|jYS0dS)Nzlatin-1Úxmlcharrefreplace) rÏr§rrÐr,rrwrÑr7r8rÒrÓrÔr-r-r.r‚’s  r‚cCsZtj}||jƒD]}|||jƒvrdSq|jj||jƒvr@dS|jj||jƒvrVdSdS)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)rÚto_listr®r¯r,rr­r¬)Út1Út2rr>r-r-r.Ú is_beforeŸsrcCs®t t¡}t t¡}|D]R}|jD]}|| |¡q"|jD]}|| |¡q<|jD]}|| |¡qVqt| ¡ƒ | ¡¡}|D]"}||D]}|j   ||¡q’q†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Ú defaultdictrr7rÙr9r8ÚkeysÚ intersectionr:rÑ)Útasksr©rªr\rÅZlinksr>r-r-r.Úset_file_constraints»s      r c@s*eZdZdZdd„Zdd„ZeedƒZdS)Ú TaskGroupz… Wrap nxm task order constraints into a single object to prevent the creation of large list/set objects This is an optimization cCs||_||_d|_dS)NF)rüÚnextZdone)r=rür r-r-r.rÙszTaskGroup.__init__cCs|jD]}|jstSqtSr@)rür4r;r‹)r=r>r-r-r.Ú get_hasrunÞs  zTaskGroup.get_hasrunN)rr/r0r1rr Úpropertyr4r-r-r-r.r Òsr c Cs t t¡}|D]}| ¡}|| |¡qt| ¡ƒ}t|ƒ}t|ƒD]Ô}|||d}t|d|ƒD]°}|||d} t|| ƒr|} |} nt| |ƒrh|} |} nqh||| } ||| } t| ƒdksÖt| ƒdkrî| D]}|j   | ¡qÚqht t | ƒt | ƒƒ} | D]}|j   | ¡qqhqFdS)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)rrrr°r¸rrlÚrangerr:rÑr rrÙ) r Z cstr_groupsr\ÚhrZmaxiÚirÚjrrÅÚbÚgroupr-r-r.Úset_precedence_constraintsæs2       rcCsi}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)ÚcZdcr-r-r.Úfunexs  rz"(?P\w+)|(?P\|)|(?P&)z^(SRC|TGT)\W+.*?$zM(?P\\)|(?P\$\$)|(?P\$\{(?P\w+)(?P.*?)\})c søg‰‡fdd„}t ||¡p|}g‰‡fdd„‰‡fdd„}g}|j}ˆD]d\}}|dkrx|rn|d|ƒn|d ƒqJ|d krœ|r’|d |ƒn|d ƒqJ|rœ| d ¡rLˆ|ƒ|dd…}|dkrÐd}nj|d krÞd}n\t |¡rúd|dd…}n@t |¡rd|dd…}n"ˆ|ƒ|dd…dvr:d|}|d||fƒnN| d¡r~t ||dd…¡}|d||fƒnd||f} ˆ| ƒ|| ƒqJˆ|ƒ|d|ƒqJ|rÈdd |¡}nd}t||f} t   d|   ¡  ¡¡t | ƒˆfS) zH Creates a compiled function to execute a process through a sub-shell csD|j}|dƒrdS|dƒrdS|dƒr@ˆ |dƒ|dƒf¡dSdS) NZdollarú$Z backslashrVÚsubstÚvarÚcodez%s)rr¸)ÚmatchÚg)Úextrr-r.Úrepl%szcompile_fun_shell..replcs|ˆvrˆ |¡dSr@©r¸©r\©r)r-r.Úadd_dvar1sz#compile_fun_shell..add_dvarcs:| d¡rdS| d¡rdS| d¡}ˆ|ƒd|SdS©NÚandz and Úorz or rzenv[%r]©r©rÕr\©r$r-r.Úreplc5s   z compile_fun_shell..replcÚSRCz 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]©rÿÚgenrJú%rz" ".join(tsk.colon(%r, %s))ú?zp(%r) if (%s) else ""ú%s%szp('%s')z%% (%s) z, rú action: %s)Úreg_actÚsubr¸Ú startswithÚre_novarrÚre_condrsÚCOMPILE_TEMPLATE_SHELLrrzÚstripÚ splitlinesr) Úliner r+ZparmÚapprÚmethrÕÚexprÚcallrr-)r$r)rr.Úcompile_fun_shell s^             rFz[(?P\s+)|(?P\$\{(?P\w+)(?P.*?)\})|(?P([^$ \t\n\r\f\v]|\$\$)+)c sjg}g‰d}|j}‡fdd„‰‡fdd„}t |¡D]ö}| d¡rNd}q4n²| d¡rv|d| d¡ d d ¡ƒnŠ| d ¡r| d ¡}| d ¡}|dkr¼|r°|d|ƒn|dƒnD|dkrâ|rÖ|d|ƒn|dƒn|rì| d¡r˜ˆ|ƒ|dd…}|dkrd}nn|dkr(d}n^t |¡rFd|dd…}n@t |¡rdd|dd…}n"ˆ|ƒ|dd…dvr†d|}|d||fƒnR| d¡rÊt  ||dd…¡}|d||fƒn d||f} ˆ| ƒ|d| ƒn|d|ƒˆ|ƒ|r(d |d!|d"f} |d"=| |d"<d#}q4d$d%„|Dƒ}t d&  |¡} t   d'|  ¡ ¡¡t| ƒˆfS)(zH Creates a compiled function to execute a process without a sub-shell Fcs|ˆvrˆ |¡dSr@r!r"r#r-r.r$|sz%compile_fun_noshell..add_dvarcs:| d¡rdS| d¡rdS| d¡}ˆ|ƒd|SdSr%r(r)r*r-r.r+€s   z"compile_fun_noshell..replcZspaceÚtextz[%r]z$$rrrrr,r1r/r-r2r0r.rNrr3r5ztsk.colon(%r, %s)r6z to_list(env[%r] if (%s) else [])r7z to_list(%s)zto_list(env[%r])z merge(%s, %s)r r TcSsg|] }d|‘qS)zlst.extend(%s)r-rbr-r-r.rdÃrez'compile_fun_noshell..ú r8)r¸Úreg_act_noshellÚfinditerrr[r;r<rr=r:ÚCOMPILE_TEMPLATE_NOSHELLrsrrzr?r@r) rAÚbufÚmergerBr+rÕrrrDrEr€r*r-)r$r)r.Úcompile_fun_noshellssp                  rNFcs®t|tƒr:| d¡dks4| d¡dks4| d¡dkr–d}n\g}g‰|D]:}t|tƒrvt||ƒ\}}||7}ˆ |¡qFˆ |¡qF‡fdd„}||fS|r¢t|ƒSt|ƒSdS) 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&&Tcs"ˆD]}||ƒ}|r|SqdSr@r-)rÚr\rS©Zfuns_lstr-r.Ú composed_funés  z!compile_fun..composed_funN)rLrMÚfindrr¸rFrN)rArZ dvars_lstr\r*r)rRr-rQr.rÈs  *    rcCsJg}t|ƒD]"}|dd…dvr | d|¡q |rFttd |¡ƒSdS)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 Nrr3zbuf.append(%s)rH)Úsortedr¸rÚCOMPILE_TEMPLATE_SIG_VARSrs)rrLr\r-r-r.r õs r r3c Cs˜|pg|||| dœ} t|tƒs(t|tƒr2|| d<n|| d<ttƒ|tf| ƒ} | t|<|rdt |¡| _|rtt |¡| _ |r„t |¡| _ |r”t |¡| _ | 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` )rr¥r%rrŒrr) rLrMr«Útyperr#rrr®r¯r¬r­) r%Úfuncrr¥r®r¯r¬r­rrŒÚparamsr$r-r-r.Ú task_factorys(û     rYcCsdd„}||_|S)zJ Task class decorator to enable rebuilds on input files task signatures cSst |¡t |¡dSr@)rrÜrõrar-r-r.rÜCs z&deep_inputs..sig_explicit_deps)rÜ)r$rÜr-r-r.Ú deep_inputs?srZc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S) Ú 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. cCs||_tƒ|_tƒ|_dS)zD :param num: maximum value of concurrent tasks :type num: int N)ÚnumrÚlockingZwaiting)r=r\r-r-r.r\szTaskSemaphore.__init__cCst|jƒ|jkS)z?Returns True if this semaphore cannot be acquired by more tasks)rlr]r\rar-r-r.Ú is_lockedeszTaskSemaphore.is_lockedcCs&| ¡rtd|jƒ‚|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^Ú IndexErrorr]rÙ©r=rÿr-r-r.ÚacquireiszTaskSemaphore.acquirecCs|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)r]r|r`r-r-r.ÚreleaseuszTaskSemaphore.releaseN)rr/r0r1rr^rarbr-r-r-r.r[Ls   r[)F)3r1rNÚrer›rur„Úwaflibrrrr;r²rˆr†r³râr‹ráràrårãr>rKrUr#rVrÚobjectrrÚ hexversionr‚rr r rrÚcompiler=r<ÚMr9rFrIrNrr rYrZZTaskBaser[r-r-r-r.Ús^("  *  RU -,