B b@sdZddlZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z ddl mZddlmZddlmZmZddlmZmZeedZd Zded d d ZejZedkrejd krdZerddZnddZe d ddZ!e d ddZ"e d ddZ#e$d ddZ%e&d ddZ'Gddde Z(e)dZ*ee&d dd Z+Gd!d"d"Z,ddgdfd#d$Z-e d d%d&Z.e/d'Z0e/d(Z1e/d)Z2e/d*Z3e/d+Z4e/d,Z5e/d-Z6e/d.Z7dd/dgdd/d/fd0d1Z8ee fZ9e:e fZ;e:e$e efZe?e9fe d d2d3Z@e?e;fe d d4d5ZAe?ed?ZFe?e=efe&d dDdEZIe?e&e>eJszcontainsAny..)any)rpatr)rr containsAnyHsr#cstfdd|DS)z.)all)rr"r)rr containsAllLsr%cCsx|D]}||krdSqWdS)z6Check whether string `s` contains ONLY items in `pat`.FTr)rr"rrrr containsOnlyPs r&cCsRt|tj}|d}||krJ||ddsJ|d|||dfS|dfS)z[Split `path` into a (root, ext) pair. Same as :mod:`os.path.splitext` but faster. .N)rosrrisdigit)rrdotrrrsplitextYs   r-cCs$tj|\}}|r ||}|S)zMake the drive letter (if any) upper case. This is useful because Windows is inconsistent on the case of the drive letter, which can cause inconsistencies when calculating command signatures. )r*r splitdriveupper)rZdriverestrrrupdrivefs r1c@sLeZdZdZddZddZddZddd d Zddd d Zd dZ dS)NodeLista?A list of Nodes with special attribute retrieval. Unlike an ordinary list, access to a member's attribute returns a `NodeList` containing the same attribute for each member. Although this can hold any object, it is intended for use when processing Nodes, where fetching an attribute of each member is very commone, for example getting the content signature of each node. The term "attribute" here includes the string representation. Example: >>> someList = NodeList([' foo ', ' bar ']) >>> someList.strip() ['foo', 'bar'] cCs t|jS)N)booldata)selfrrr__bool__szNodeList.__bool__cCsdtt|jS)N )joinmapstrr4)r5rrr__str__szNodeList.__str__cCs t|jS)N)iterr4)r5rrr__iter__szNodeList.__iter__)r cs fdd|jD}||S)Ncsg|]}|qSrr)rx)argskwargsrr sz%NodeList.__call__..)r4 __class__)r5r?r@rr)r?r@r__call__szNodeList.__call__csfdd|jD}||S)z.Returns a NodeList of `name` from each member.csg|]}t|qSr)getattr)rr>)namerrrAsz(NodeList.__getattr__..)r4rB)r5rErr)rEr __getattr__szNodeList.__getattr__cCs$t|tr||j|S|j|S)zYnXdS)N )print_itsysstdoutwriter:IOError)r5textZappend_newlinerrrrCszDisplayEngine.__call__cCs ||_dS)N)rY)r5moderrrset_modeszDisplayEngine.set_modeN)r()rKrLrMrNrYrCr`rrrrrWs rWc Cst|}|dkri}||}d}x*|ddD]}|r@|d}q.|d}q.W||krd|d|dS|d|d }|st|}d ||<xFt|D]:\} } || t|d k|t| ||||}|qW|S) aRender a tree of nodes into an ASCII tree view. Args: root: the root node of the tree child_func: the function called to get the children of a node prune: don't visit the same node twice margin: the format of the left margin to use for children of `root`. 1 results in a pipe, and 0 results in no pipe. visited: a dictionary of visited nodes in the current branch if `prune` is 0, or in the whole tree if `prune` is 1. Nr)rPz| z z+-[z] z+-rXTr()r:copy enumerateappendlen render_treepop) root child_funcprunemarginvisitedrnamechildrenZretvalpipeiZchildrrrres(     recCst|S)zzGenerate in index into strings from the tree legends. These are always a choice between two, so bool works fine. )r3)nrrrIDXsrqi%i%i%i %i%i%i%i,%Fc sFt|}|dkri}|r|dkr0d} tj| ddt|dt|oT| ddd gt|ddgt|d t|j d t|j d t|j d t| dt|j dt|jdg } ng} fdd} tt| |dd} ||} d}rPtt}|r"tt}| rP|rH||krH| rH|t7}n|t7}|r||kr| rtjd| | |d|dgddStjd| | ||gdd ||<| rB|d t|}d}x@| ddD]0}|d }t||||||t| |dkqWd|d<t| d|||||d|dS)aPrint a tree of nodes. This is like func:`render_tree`, except it prints lines directly instead of creating a string representation in memory, so that huge trees can be handled. Args: root: the root node of the tree child_func: the function called to get the children of a node prune: don't visit the same node twice showtags: print status information to the left of each node line margin: the format of the left margin to use for children of `root`. 1 results in a pipe, and 0 results in no pipe. visited: a dictionary of visited nodes in the current branch if prune` is 0, or in the whole tree if `prune` is 1. singleLineDraw: use line-drawing characters rather than ASCII. Na E = exists R = exists in repository only b = implicit builder B = explicit builder S = side effect P = precious A = always build C = current N = no clean H = no cache [z Ez Rz BbBrr(z Sz Pz Az Cz Nz H]cs rdtdg|Sddg|S)Nz r7z| )BOX_VERT)m)singleLineDrawrrMMMRszprint_tree..MMMrPz+-r)rXT)r:rZr[r\rqexistsZrexistsZhas_explicit_builderZ has_builderZ side_effectZpreciousZ always_buildZ is_up_to_dateZnocleanZnocachelistr9BOX_VERT_RIGHT BOX_HORIZ BOX_UP_RIGHTBOX_HORIZ_DOWNr8rc print_treerdrf)rgrhriZshowtagsrjrkZ lastChildrwrlZlegendZtagsrxZmarginsrmZcrossidxZ_childCr)rwrr sp         &"  rcCs |||S)Nr)objrG DictTypesrrris_DictsrcCs |||S)Nr)rrG ListTypesrrris_ListsrcCs |||S)Nr)rrG SequenceTypesrrr is_SequencesrcCs |||S)Nr)rrGtuplerrris_TuplesrcCs |||S)Nr)rrG StringTypesrrr is_StringsrcCs|||p||| S)Nr)rrGrrrrr is_Scalars rcCs<x6|D].}|||s|||s*||qt||qWdS)N)rc do_flatten)sequencerrGrritemrrrrs  rcCsZ|||s|||s|gSg}x6|D].}|||s<|||sH||q$|||q$W|S)zFlatten a sequence to a non-nested list. Converts either a single scalar or a nested sequence to a non-nested list. Note that :func:`flatten` considers strings to be scalars instead of sequences like pure Python would. )rc)rrGrrrrrrrrflattens   rcCs@g}x6|D].}|||s"|||s.||q |||q W|S)zFlatten a sequence to a non-nested list. Same as :func:`flatten`, but it does not handle the single scalar case. This is slightly more efficient when one knows that the sequence to flatten can not be a scalar. )rc)rrGrrrrrrrrflatten_sequences   rcCs&|||r|S|||r|jS||S)zReturn a string version of obj.)r4)rrGr:rBaseStringTypesrrrrSs  rScCsD|||r|S|||r,ddd|DS|||r<|jS||S)z/Return a string version of obj for subst usage.r7cSsg|] }t|qSr)to_String_for_subst)rerrrrA6sz'to_String_for_subst..)r8r4)rrGr:rrrrrrr's   rcCsFy |j}Wn0|k r:t|tr2tj|ddS||SX|SdS)zReturn a string version of obj for signature usage. Like :func:`to_String_for_subst` but has special handling for scons objects that have a :meth:`for_signature` method, and for dicts. i@B)widthN)Z for_signaturerGdictpprintZpformat)rrAttributeErrorfrrrto_String_for_signature>s    rcs"dkr gfdd|DS)Ncs"i|]\}}|krt||qSr) semi_deepcopy)rkv)excluderr esz&semi_deepcopy_dict..)items)rrr)rrsemi_deepcopy_dictbsrcCsdd|DS)NcSsg|] }t|qSr)r)rrrrrrAhsz'_semi_deepcopy_list..r)rrrr_semi_deepcopy_listgsrcCsttt|S)N)rr9r)rrrr_semi_deepcopy_tuplejsrcCsjtt|}|r||St|dr6t|jr6|St|trN|t |St|t rf|t |S|S)N__semi_deepcopy__) _semi_deepcopy_dispatchgettypehasattrcallablerrGrrBrrr)rZcopierrrrrss  rc@s0eZdZdZddZddZddZdd Zd S) ProxyaA simple generic Proxy class, forwarding all calls to subject. This means you can take an object, let's call it `'obj_a`, and wrap it in this Proxy class, with a statement like this:: proxy_obj = Proxy(obj_a) Then, if in the future, you do something like this:: x = proxy_obj.var1 since the :class:`Proxy` class does not have a :attr:`var1` attribute (but presumably `objA` does), the request actually is equivalent to saying:: x = obj_a.var1 Inherit from this class to create a Proxy. With Python 3.5+ this does *not* work transparently for :class:`Proxy` subclasses that use special .__*__() method names, because those names are now bound to the class, not the individual instances. You now need to know in advance which special method names you want to pass on to the underlying Proxy object, and specifically delegate their calls like this:: class Foo(Proxy): __str__ = Delegate('__str__') cCs ||_dS)z Wrap an object as a Proxy objectN)_subject)r5Zsubjectrrr__init__szProxy.__init__cCs t|j|S)zRetrieve an attribute from the wrapped object. Raises: AttributeError: if attribute `name` doesn't exist. )rDr)r5rErrrrFszProxy.__getattr__cCs|jS)z"Retrieve the entire wrapped object)r)r5rrrrsz Proxy.getcCs&t|j|jjr|j|kS|j|jkS)N) issubclassrBr__dict__)r5otherrrr__eq__s z Proxy.__eq__N)rKrLrMrNrrFrrrrrrrs rc@s eZdZdZddZddZdS)DelegatezA Python Descriptor class that delegates attribute fetches to an underlying wrapped subject of a Proxy. Typical use:: class Foo(Proxy): __str__ = Delegate('__str__') cCs ||_dS)N) attribute)r5rrrrrszDelegate.__init__cCst||rt|j|jS|S)N)rGrDrr)r5rclsrrr__get__s zDelegate.__get__N)rKrLrMrNrrrrrrrsrc@s*eZdZdZd ddZddZddZdS) MethodWrapperaA generic Wrapper class that associates a method with an object. As part of creating this MethodWrapper object an attribute with the specified name (by default, the name of the supplied method) is added to the underlying object. When that new "method" is called, our :meth:`__call__` method adds the object as the first argument, simulating the Python behavior of supplying "self" on method calls. We hang on to the name by which the method was added to the underlying base class so that we can provide a method to "clone" ourselves onto a new underlying object being copied (without which we wouldn't need to save that info). NcCs2|dkr|j}||_||_||_t|j||dS)N)rKobjectmethodrEsetattr)r5rrrErrrrs zMethodWrapper.__init__cOs|jf|}|j||S)N)rr)r5r?r@nargsrrrrCs zMethodWrapper.__call__cCs|||j|jS)zn Returns an object that re-binds the underlying "method" to the specified new object. )rBrrE)r5Z new_objectrrrcloneszMethodWrapper.clone)N)rKrLrMrNrrCrrrrrrs  rTc@s eZdZdS)_NoErrorN)rKrLrMrrrrrsrcCs>|dd}|d|d}||d}t||}t||S)aReturns a registry value without having to open the key first. Only available on Windows platforms with a version of Python that can read the registry. Returns the same thing as :func:`RegQueryValueEx`, except you just specify the entire path to the value, and don't have to bother opening the key first. So, instead of:: k = SCons.Util.RegOpenKeyEx(SCons.Util.HKEY_LOCAL_MACHINE, r'SOFTWARE\Microsoft\Windows\CurrentVersion') out = SCons.Util.RegQueryValueEx(k, 'ProgramFilesDir') You can write:: out = SCons.Util.RegGetValue(SCons.Util.HKEY_LOCAL_MACHINE, r'SOFTWARE\Microsoft\Windows\CurrentVersion\ProgramFilesDir') \r(N)r RegOpenKeyExRegQueryValueEx)rgkeypZkeypvalrrrr RegGetValues   rcCstdS)N)OSError)rgrrrrr&scCstdS)N)r)rgrrrrr)src CsL|dkr,ytjd}Wntk r*dSXt|r@|tj}|dkrpytjd}Wntk rnd}YnXt|r|tj}x2|D]*}||t| dkrdg}PqW|dkrg}t|st |s|g}xl|D]d}tj ||}xP|D]H}||}tj |ry| |Wqtk r<tj |SXqqWqWdS)NPATHZPATHEXTz.COM;.EXE;.BAT;.CMDr))r*environKeyErrorrsplitpathseplowerrdrrrr8isfilerI ValueErrornormpath)filerpathextrejectextrrfextrrrWhereIs/sB        rZos2c Cs|dkr,ytjd}Wntk r*dSXt|r@|tj}|dkrPddg}x2|D]*}||t| dkrVdg}PqVW|dkrg}t|st |s|g}xl|D]d}tj ||}xP|D]H}||}tj |ry| |Wqtk rtj |SXqqWqWdS)Nrz.exez.cmdr))r*rrrrrrrdrrrr8rrIrr)rrrrrrrrrrrrTs8      c Csddl}|dkr4ytjd}Wntk r2dSXt|rH|tj}|dkrTg}t|sjt|sj|g}x|D]}tj ||}tj |rpyt|}Wnt k rwpYnX| ||jd@rpy||Wqptk rtj |SXqpqpWdS)NrrI)statr*rrrrrrrrr8rrS_IMODEST_MODErIrr)rrrrrrrstrrrrts4   aReturn the path to an executable that matches `file`. Searches the given `path` for `file`, respecting any filename extensions `pathext` (on the Windows platform only), and returns the full path to the matching command. If no command is found, return ``None``. If `path` is not specified, :attr:`os.environ[PATH]` is used. If `pathext` is not specified, :attr:`os.environ[PATHEXT]` is used. Will not select any path name or names in the optional `reject` list. c Cs~|}d}|}t|s*t|s*||}d}t|r>||}nt|sVt|sV|g}n|}|rltt||}|sg} g} xB|D]:} | sqtjtj | } | | kr| | | | qW| xD|D]<} | sqtjtj | } | | kr| d| | | qW| }nX||}g} g}xF|D]>} tjtj | } | r(| | kr(| | | | q(W|rt|S| |S)aPrepends `newpath` path elements to `oldpath`. Will only add any particular path once (leaving the first one it encounters and ignoring the rest, to preserve path order), and will :mod:`os.path.normpath` and :mod:`os.path.normcase` all paths to help assure this. This can also handle the case where `oldpath` is a list instead of a string, in which case a list will be returned instead of a string. For example: >>> p = PrependPath("/foo/bar:/foo", "/biz/boom:/foo") >>> print(p) /biz/boom:/foo:/foo/bar If `delete_existing` is ``False``, then adding a path that exists will not move it to the beginning; it will stay where it is in the list. >>> p = PrependPath("/foo/bar:/foo", "/biz/boom:/foo", delete_existing=False) >>> print(p) /biz/boom:/foo/bar:/foo If `canonicalize` is not ``None``, it is applied to each element of `newpath` before use. TFr)rrrrrzr9r*rrnormcasercreverseinsertr8) oldpathnewpathrdelete_existing canonicalizeorigis_listpathsnewpathsr normpathsrrrrr PrependPathsV        rc Csv|}d}|}t|s*t|s*||}d}t|r>||}nt|sVt|sV|g}n|}|rltt||}|sg} g} x6|D].} | sq~| | | tj tj | q~WxB|D]:} | sqtj tj | } | | kr| | | | qW| }nh||}| g} g}xF|D]>} tj tj | } | r| | kr|| | | qW| |rl|S| |S)aAppends `newpath` path elements to `oldpath`. Will only add any particular path once (leaving the last one it encounters and ignoring the rest, to preserve path order), and will :mod:`os.path.normpath` and :mod:`os.path.normcase` all paths to help assure this. This can also handle the case where `oldpath` is a list instead of a string, in which case a list will be returned instead of a string. For example: >>> p = AppendPath("/foo/bar:/foo", "/biz/boom:/foo") >>> print(p) /foo/bar:/biz/boom:/foo If `delete_existing` is ``False``, then adding a path that exists will not move it to the end; it will stay where it is in the list. >>> p = AppendPath("/foo/bar:/foo", "/biz/boom:/foo", delete_existing=False) >>> print(p) /foo/bar:/foo:/biz/boom If `canonicalize` is not ``None``, it is applied to each element of `newpath` before use. TF) rrrrrzr9rcr*rrrrr8) rrrrrrrrrrrrrrrr AppendPathsT        rcCsynd}||}t||s(||}d}tj|tttjj|krP|g|}|r^|||<n||||<Wntk r|||<YnXdS)aAdd a path element to a construction variable. `key` is looked up in `env_dict`, and `path` is added to it if it is not already present. `env_dict[key]` is assumed to be in the format of a PATH variable: a list of paths separated by `sep` tokens. Example: >>> env = {'PATH': '/bin:/usr/bin:/usr/local/bin'} >>> AddPathIfNotExists(env, 'PATH', '/opt/bin') >>> print(env['PATH']) /opt/bin:/bin:/usr/bin:/usr/local/bin TFN) rrr*rrrzr9r8r)Zenv_dictrrrrrrrrAddPathIfNotExistsOs    rcygwincCs*tjdd|fdtjd}|jddS)NZcygpathz-wF)Zcheckr[rXr)) subprocessrunPIPEr[decodereplace)rZcprrrget_native_pathosrcCs|S)Nr)rrrrrsszTransform an absolute path into a native path for the system. In Cygwin, this converts from a Cygwin path to a Windows path, without regard to whether `path` refers to an existing file system object. For other platforms, `path` is unchanged. cCs*t|st|r|St|r$|S|gS)aReturns a list of file names or other objects. If `arg` is a string, it will be split on strings of white-space characters within the string. If `arg` is already a list, the list will be returned untouched. If `arg` is any other type of object, it will be returned as a list containing just the object. >>> print(Split(" this is a string ")) ['this', 'is', 'a', 'string'] >>> print(Split(["stringlist", " preserving ", " spaces "])) ['stringlist', ' preserving ', ' spaces '] )rrrr)argrrrSplits rcsNeZdZdZd fdd ZfddZfddZfd d Zd d ZZ S)CLVaraA container for command-line construction variables. Forces the use of a list of strings intended as command-line arguments. Like :class:`collections.UserList`, but the argument passed to the initializter will be processed by the :func:`Split` function, which includes special handling for string types: they will be split into a list of words, not coereced directly to a list. The same happens if a string is added to a :class:`CLVar`, which allows doing the right thing with both :func:`Append`/:func:`Prepend` methods, as well as with pure Python addition, regardless of whether adding a list or a string to a construction variable. Side effect: spaces will be stripped from individual string arguments. If you need spaces preserved, pass strings containing spaces inside a list argument. >>> u = UserList("--some --opts and args") >>> print(len(u), repr(u)) 22 ['-', '-', 's', 'o', 'm', 'e', ' ', '-', '-', 'o', 'p', 't', 's', ' ', 'a', 'n', 'd', ' ', 'a', 'r', 'g', 's'] >>> c = CLVar("--some --opts and args") >>> print(len(c), repr(c)) 4 ['--some', '--opts', 'and', 'args'] >>> c += " strips spaces " >>> print(len(c), repr(c)) 6 ['--some', '--opts', 'and', 'args', 'strips', 'spaces'] Ncs tt|dk r|ngdS)N)superrr)r5initlist)rBrrrszCLVar.__init__cstt|S)N)r__add__r)r5r)rBrrrsz CLVar.__add__cstt|S)N)r__radd__r)r5r)rBrrrszCLVar.__radd__cstt|S)N)r__iadd__r)r5r)rBrrrszCLVar.__iadd__cCsddd|jDS)Nr7cSsg|] }t|qSr)r:)rdrrrrAsz!CLVar.__str__..)r8r4)r5rrrr;sz CLVar.__str__)N) rKrLrMrNrrrrr; __classcell__rr)rBrrs    rc@seZdZdZdddZdS)SelectorzA callable ordered dictionary that maps file suffixes to dictionary values. We preserve the order in which items are added so that :func:`get_suffix` calls always return the first suffix added. NcCs|dkr2y|d}Wntk r0d}YnXy||Stk ri}xN|D]B\}}|dk rX||}||krt||d||||f||<qXWy ||dStk ry|dStk rdSXYnXYnXdS)Nrr)r()Z get_suffix IndexErrorrrZsubst)r5envsourcerZs_dictrrZs_krrrrCs,   zSelector.__call__)N)rKrLrMrNrCrrrrrsrcCsdS)NFr)s1s2rrrcase_sensitive_suffixessrcCstj|tj|kS)N)r*rr)rrrrrrscCsj|r@tjtj|\}}||r.||kr@tj|||}|rf||sf|s^t|dsf||}|S)zAdjust filename prefixes and suffixes as needed. Add `prefix` to `fname` if specified. Add `suffix` to `fname` if specified and if `ensure_suffix` is ``True`` r()r*rrr startswithr8endswithr-)fnameZpreZsufZ ensure_suffixrfnrrr adjustixessrc Cs|sgStttt|SQRXt|}y t|}Wntk rNYnXX|d}d}}x8||kr|||kr||||<}|d}|d}qbW|d|Sg}x|D]}||kr||qW|S)aRReturn a list of the elements in seq without duplicates, ignoring order. >>> mylist = unique([1, 2, 3, 1, 2, 3]) >>> print(sorted(mylist)) [1, 2, 3] >>> mylist = unique("abcabc") >>> print(sorted(mylist)) ['a', 'b', 'c'] >>> mylist = unique(([1, 2], [2, 3], [1, 2])) >>> print(sorted(mylist)) [[1, 2], [2, 3]] For best speed, all sequence elements should be hashable. Then unique() will usually work in linear time. If not possible, the sequence elements should enjoy a total ordering, and if list(s).sort() doesn't raise TypeError it's assumed that they do enjoy a total ordering. Then unique() will usually work in O(N*log2(N)) time. If that's not possible either, the sequence elements must support equality-testing. Then unique() will usually work in quadratic time. Nrr()r TypeErrorrzrfromkeysrdsortedrc)seqrptZlastZlastirour>rrruniques,        r cCsRdd}|s|}i}g}|j}x.|D]&}||}||kr:q$d||<||q$W|S)NcSs|S)Nr)r>rrr default_idfun_szuniquer..default_idfunr()rc)rZidfunr seenr result_appendrZmarkerrrruniquer^s  rcCs8i}g}|j}x$|D]}||krd||<||qW|S)Nr()rc)rr rrrrrruniquer_hashablesrs  rr)ccsbg}xJ|D]B}|}|dr4||ddq ||||Vg}q W|r^||VdS)NrrP)rstriprrc)Zphysical_linesZjoinerZ logical_linelinestrippedrrr logical_liness    rc@s eZdZdZddZddZdS) LogicalLinesz~ Wrapper class for the logical_lines method. Allows us to read all "logical" lines at once from a given file object. cCs ||_dS)N)fileobj)r5rrrrrszLogicalLines.__init__cCstt|jS)N)rzrr)r5rrr readlinesszLogicalLines.readlinesN)rKrLrMrNrrrrrrrsrcs>eZdZdZd5fdd ZddZfddZfd d Zfd d Zfd dZ fddZ fddZ fddZ fddZ fddZfddZfddZfddZfdd Zfd!d"Zfd#d$Zfd%d&Zfd'd(Zfd)d*Zfd+d,Zfd-d.Zfd/d0Zfd1d2Zfd3d4ZZS)6 UniqueLista A list which maintains uniqueness. Uniquing is lazy: rather than being assured on list changes, it is fixed up on access by those methods which need to act on a uniqe list to be correct. That means things like "in" don't have to eat the uniquing time. Ncst|d|_dS)NT)rrr )r5r)rBrrrs zUniqueList.__init__cCs|jst|j|_d|_dS)NT)r rr4)r5rrrZ __make_uniques zUniqueList.__make_uniquecs|tS)N)_UniqueList__make_uniquer__repr__)r5)rBrrrszUniqueList.__repr__cs|t|S)N)rr__lt__)r5r)rBrrrszUniqueList.__lt__cs|t|S)N)rr__le__)r5r)rBrrrszUniqueList.__le__cs|t|S)N)rrr)r5r)rBrrrszUniqueList.__eq__cs|t|S)N)rr__ne__)r5r)rBrrrszUniqueList.__ne__cs|t|S)N)rr__gt__)r5r)rBrrrszUniqueList.__gt__cs|t|S)N)rr__ge__)r5r)rBrrrszUniqueList.__ge__cs|tS)N)rr__len__)r5)rBrrr szUniqueList.__len__cs|t|S)N)rrrJ)r5ro)rBrrrJszUniqueList.__getitem__cst||d|_dS)NF)r __setitem__r )r5ror)rBrrr!szUniqueList.__setitem__cst|}d|_|S)NF)rrr )r5rr)rBrrrs zUniqueList.__add__cst|}d|_|S)NF)rrr )r5rr)rBrrrs zUniqueList.__radd__cst|}d|_|S)NF)rrr )r5rr)rBrrrs zUniqueList.__iadd__cst|}d|_|S)NF)r__mul__r )r5rr)rBrrr"s zUniqueList.__mul__cst|}d|_|S)NF)r__rmul__r )r5rr)rBrrr#s zUniqueList.__rmul__cst|}d|_|S)NF)r__imul__r )r5rr)rBrrr$s zUniqueList.__imul__cst|d|_dS)NF)rrcr )r5r)rBrrrcs zUniqueList.appendcst||d|_dS)NF)rrr )r5ror)rBrrrszUniqueList.insertcs|t|S)N)rrcount)r5r)rBrrr%szUniqueList.countcs|tj|f|S)N)rrrI)r5rr?)rBrrrIszUniqueList.indexcs|tdS)N)rrr)r5)rBrrrszUniqueList.reversecs|tj||S)N)rrsort)r5r?kwds)rBrrr& szUniqueList.sortcst|d|_dS)NF)rextendr )r5r)rBrrr(s zUniqueList.extend)N)rKrLrMrNrrrrrrrrrr rJr!rrrr"r#r$rcrr%rIrr&r(rrr)rBrrs4                      rc@s0eZdZdZddZddZddZdd Zd S) UnbufferedzyA proxy that wraps a file object, flushing after every write. Delegates everything else to the wrapped object. cCs ||_dS)N)r)r5rrrrrszUnbuffered.__init__c Cs.tt|j||jWdQRXdS)N)rr]rr\flush)r5rrrrr\s  zUnbuffered.writec Cs.tt|j||jWdQRXdS)N)rr]r writelinesr*)r5rrrrr+)s  zUnbuffered.writelinescCs t|j|S)N)rDr)r5attrrrrrF.szUnbuffered.__getattr__N)rKrLrMrNrr\r+rFrrrrr)s  r)cCsZtj|rBtj|\}}|s6td|d}n |dd}tj|rVt||S)z6Converts an absolute path name to a relative pathname.z/*(.*)rr(N)r*risabsr.recompilefindallAssertionError)rZdrive_srrrmake_path_relative1s  r2cCs||dkr|j}nt|j|j||j}t|drh|jtk rht|dr\t|||}|j |qlt ||}n|}t |||dS)avAdds a method to an object. Adds `function` to `obj` if `obj` is a class object. Adds `function` as a bound method if `obj` is an instance object. If `obj` looks like an environment instance, use `MethodWrapper` to add it. If `name` is supplied it is used as the name of `function`. Although this works for any class object, the intent as a public API is to be used on Environment, to be able to add a method to all construction environments; it is preferred to use env.AddMethod to add to an individual environment. >>> class A: ... ... >>> a = A() >>> def f(self, x, y): ... self.z = x + y >>> AddMethod(A, f, "add") >>> a.add(2, 4) >>> print(a.z) 6 >>> a.data = ['a', 'b', 'c', 'd', 'e', 'f'] >>> AddMethod(a, lambda self, i: self.data[i], "listIndex") >>> print(a.listIndex(3)) d NrB added_methods) rKr __code__ __globals__ __defaults__rrBrrr3rcrr)rZfunctionrErrrr AddMethodOs   r7Zmd5Zsha1Zsha256cCs@|dkr dS|jjdks0|jjdkr:|jjdkr:|ddS|S)aPython 3.9 and onwards lets us initialize the hash function object with the key "usedforsecurity"=false. This lets us continue to use algorithms that have been deprecated either by FIPS or by Python itself, as the MD5 algorithm SCons prefers is not being used for security purposes as much as a short, 32 char hash that is resistant to accidental collisions. In prior versions of python, hashlib returns a native function wrapper, which errors out when it's queried for the optional parameter, so this function wraps that call. It can still throw a ValueError if the initialization fails due to FIPS compliance issues, but that is assumed to be the responsibility of the caller. N F)Zusedforsecurity) version_infomajorminor)Zhash_function_objectsys_usedrrr'_attempt_init_of_python_3_9_hash_objects $ r>c Csd}gaxbtD]Z}t||d}|dk ryt||t|Wqtk rf}z |}wWdd}~XYqXqWttdkrddlm}|d|dS)aChecks if SCons has ability to call the default algorithms normally supported. This util class is sometimes called prior to setting the user-selected hash algorithm, meaning that on FIPS-compliant systems the library would default-initialize MD5 and throw an exception in set_hash_format. A common case is using the SConf options, which can run prior to main, and thus ignore the options.hash_format variable. This function checks the DEFAULT_HASH_FORMATS and sets the ALLOWED_HASH_FORMATS to only the ones that can be called. In Python >= 3.9 this will always default to MD5 as in Python 3.9 there is an optional attribute "usedforsecurity" set for the method. Throws if no allowed hash formats are detected. Nr)SConsEnvironmentErrorzQNo usable hash algorithms found.Most recent error from hashlib attached in trace.) ALLOWED_HASH_FORMATSDEFAULT_HASH_FORMATSrDr>rcrrd SCons.Errorsr?) hashlib_usedr=Z _last_errorZtest_algorithmZ _test_hashrr?rrr"_set_allowed_viable_default_hashess"     rDcCstS)aRetrieves the hash format or ``None`` if not overridden. A return value of ``None`` does not guarantee that MD5 is being used; instead, it means that the default precedence order documented in :func:`SCons.Util.set_hash_format` is respected. ) _HASH_FORMATrrrrget_hash_formatsrFcCs@y&t||d}|dkrdSt|||Stk r:dSXdS)zWrapper used to try to initialize a hash function given. If successful, returns the name of the hash function back to the user. Otherwise returns None. N)rDr>r)Z hash_namerCr=Z _fetch_hashrrr_attempt_get_hash_functions  rGcCs|a|r|}|tkrddlm}|tkrD|d|dtfn>ttkrd|d|dtfn|d|dtdtft|||atdkrddlm}|d|n8x6tD]}t|||atdk rPqWddlm}|d dS) aSets the default hash format used by SCons. If `hash_format` is ``None`` or an empty string, the default is determined by this function. Currently the default behavior is to use the first available format of the following options: MD5, SHA1, SHA256. r) UserErrorzWhile hash format "%s" is supported by SCons, the local system indicates only the following hash formats are supported by the hashlib library: %sz, z]Hash format "%s" is not supported by SCons. Only the following hash formats are supported: %szHash format "%s" is not supported by SCons. SCons supports more hash formats than your local system is reporting; SCons supports: %s. Your local system only supports: %sNzHash format "%s" is not available in your Python interpreter. Expected to be supported algorithm by set_allowed_viable_default_hashes, Assertion error in SCons.zYour Python interpreter does not have MD5, SHA1, or SHA256. SCons requires at least one. Expected to support one or more during set_allowed_viable_default_hashes.) rErr@rBrHrAr8rG_HASH_FUNCTION) hash_formatrCr=Zhash_format_lowerrHZchoicerrrset_hash_formats<        rKcCstS)aReturns the current hash algorithm name used. Where the python version >= 3.9, this is expected to return md5. If python's version is <= 3.8, this returns md5 on non-FIPS-mode platforms, and sha1 or sha256 on FIPS-mode Linux platforms. This function is primarily useful for testing, where one expects a value to be one of N distinct hashes, and therefore the test needs to know which hash to select. )rIrrrrget_current_hash_algorithm_usedLs rLcCsh|dkr6tdkr$ddlm}|dtt|td|Stt|sXddlm}|d|ttt||S)zAllocates a hash object using the requested hash format. Args: hash_format: Hash format to use. Returns: hashlib object. Nr)rHz`There is no default hash function. Did you call a hashing function before SCons was initialized?z=Hash format "%s" is not available in your Python interpreter.)rIrBrHr>rDrhashlib)rJrCr=rHrrr_get_hash_objectXs    rNcCsJt|}y|t|Wn&tk r@|tt|YnX|S)z Generate hash signature of a string Args: s: either string or bytes. Normally should be bytes hash_format: Specify to override default hash format Returns: String of hex digits representing the signature )rNr to_bytesrr: hexdigest)rrJrvrrrhash_signaturess rQc CsJt|}t|d*}x"||}|s&P|t|qWWdQRX|S)z Generate the md5 signature of a file Args: fname: file to hash chunksize: chunk size to read hash_format: Specify to override default hash format Returns: String of Hex digits representing the signature rbN)rNopenreadr rOrP)r chunksizerJrvrZblckrrrhash_file_signatures   rWcCs$t|dkr|dStd||S)z Collects a list of signatures into an aggregate signature. Args: signatures: a list of signatures hash_format: Specify to override default hash format Returns: the aggregate signature r(rz, )rdrQr8) signaturesrJrrr hash_collects rYcCs*ts&ddl}|j|jjd|dadS)z6Shows a deprecation warning for various MD5 functions.rNzFunction %s is deprecatedT)_MD5_WARNING_SHOWNZSCons.WarningsZWarningswarnZDeprecatedWarning)Z function_nameZSConsrrr_show_md5_warnings   r\cCstdt|S)z/Deprecated. Use :func:`hash_signature` instead. MD5signature)r\rQ)rrrrr]sr]cCstdt||S)z4Deprecated. Use :func:`hash_file_signature` instead.MD5filesignature)r\rW)rrVrrrr^sr^cCstdt|S)z-Deprecated. Use :func:`hash_collect` instead. MD5collect)r\rY)rXrrrr_sr_cCs$y t|Stk r|SXdS)z Perform :mod:`sys.intern` on the passed argument and return the result. If the input is ineligible for interning the original argument is returned and no exception is thrown. N)rZinternr)r>rrr silent_interns racsXeZdZdZfddZddZddZdd Zd d Zd d Z ddZ ddZ Z S)Nullz0 Null objects always and reliably "do nothing." cs,dt|kr&tt|j|f|||_|jS)N _instance)varsrrb__new__rc)rr?r@)rBrrres z Null.__new__cOsdS)Nr)r5r?r@rrrrsz Null.__init__cOs|S)Nr)r5r?r@rrrrCsz Null.__call__cCs dt|S)Nz Null(0x%08X))id)r5rrrrsz Null.__repr__cCsdS)NFr)r5rrrr6sz Null.__bool__cCs|S)Nr)r5rErrrrFszNull.__getattr__cCs|S)Nr)r5rEvaluerrr __setattr__szNull.__setattr__cCs|S)Nr)r5rErrr __delattr__szNull.__delattr__) rKrLrMrNrerrCrr6rFrhrirrr)rBrrbs rbc@s8eZdZdZddZddZddZdd Zd d Zd S) NullSeqz/ A Null object that can also be iterated over. cCsdS)Nrr)r5rrrr szNullSeq.__len__cCstdS)Nr)r<)r5rrrr=szNullSeq.__iter__cCs|S)Nr)r5rorrrrJszNullSeq.__getitem__cCs|S)Nr)r5rorrr __delitem__szNullSeq.__delitem__cCs|S)Nr)r5rorrrrr!szNullSeq.__setitem__N) rKrLrMrNr r=rJrkr!rrrrrjs rjcCs(|dkr dSt|ttfr|St|dS)NsNonezutf-8)rGbytes bytearray)rrrrrO s rOcCs"|dkr dSt|r|St|dS)NNonezutf-8)rr:)rrrrto_strs rocCs||k||kS)z=A cmp function because one is no longer available in python3.r)abrrrcmpsrrcCspy ||}Wntk r |SXy tt|Stk rjt|dkrRdSt|dkrfdS|SXdS)alConvert a construction variable to bool. If the value of `name` in `env` is 'true', 'yes', 'y', 'on' (case insensitive) or anything convertible to int that yields non-zero then return ``True``; if 'false', 'no', 'n', 'off' (case insensitive) or a number that converts to integer zero return ``False``. Otherwise, return `default`. Args: env: construction environment, or any dict-like object name: name of the variable default: value to return if `name` not in `env` or cannot be converted (default: False) Returns: the "truthiness" of `name` )trueZyesyZonT)ZfalseZnorpZoffFN)rr3intrr:r)rrEdefaultrUrrr get_env_bools  rwcCsttj||S)zfConvert an environment variable to bool. Conversion is the same as for :func:`get_env_bool`. )rwr*r)rErvrrrget_os_env_boolAsrxcCsddlm}|S)z6Hack to return a value from Main if can't import Main.r) print_time)ZSCons.Script.Mainry)ryrrrryIs ryc Csy6ddl}x(|dd|Dkr&Pq tdq WWntk rxtjdkrddl}d}|jj |d|}|dkr|Pq|jj |tdqHyt |dWntk rPYqHXtdqHWYnXdS)z Wait for specified process to die, or alternatively kill it NOTE: This function operates best with psutil pypi package TODO: Add timeout which raises exception rNcSsg|] }|jqSr)pid)rprocrrrrAZsz+wait_for_process_to_die..g?ri)psutilZ process_itertimeZsleep ImportErrorrZplatformctypesZwindllZkernel32Z OpenProcessZ CloseHandler*killr)rzr|rZPROCESS_QUERY_INFORMATIONZ processHandlerrrwait_for_process_to_diePs*  r)N)N)NNN)NNN)NNN)F)N)N)N)rRN)N)rR)F)F)rNrarMr*rr.rZr} collectionsrrrrZcollections.abcr contextlibrtypesrr typingr r rZPYPYZNOFILErraltseprrrr3r#r%r&rr-r:r1r2r/rQrVrWrerqchrr|rur}ZBOX_DOWN_RIGHTZ BOX_DOWN_LEFTZ BOX_UP_LEFTr{r~rrrzrrrrrGrrrrrrrrrrSrrrrrrrrrrrZ can_read_regwinregZhkey_modr~ ExceptionrZRegErrorZHKEY_CLASSES_ROOTHKEY_LOCAL_MACHINEHKEY_CURRENT_USERZ HKEY_USERSZ OpenKeyExrZEnumKeyZ RegEnumKeyZ EnumValueZ RegEnumValueZ QueryValueExrerrorrrrErrrrrrZdisplayrrrrrr rrr8rrrr)r2r7rAr@rIrEr>rDrFrGrKrLrNrQrWrYrZr\r]r^r_rarbrjrlrOrorrrwrxryrrrrrsz       + *   "4#   #  - U T  /$  I   x 6   , U       "