B b#@sXdZddlZddlZddlZddlZddlZddlmZddlZ ddl Z ddl Z ddl m Z ddl Z ddlmZmZddlZ ddlZ ddlZ ddlZ ddlZ ddlZ ddlZ ddlZ ddlZ ddlZ ddlZ ddlmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-GdddZ.e.Z/d Z0d Z1d Z2ia3iZ4d d Z5e j6j6e5e j7j8j9j8e j7j:j;d dd d ZgZ?ddZ@ddZAddZBddZCd d!ZDd"d#ZEd$d%ZFGd&d'd'e ZGGd(d)d)eZHeId*ZJd+d,ZKGd-d.d.ZLd=d/d0ZMd>d1d2ZNd3d4ZOd5d6ZPGd7d8d8eLZQGd9d:d:eQZReQZSd;d<ZTdS)?a"Base class for construction Environments. These are the primary objects used to communicate dependency and construction information to the build engine. Keyword arguments supplied when the construction Environment is created are construction variables used to initialize the Environment. N)UserDict)logInstanceCreation) UserError BuildError) AppendPathCLVar LogicalLines MethodWrapper PrependPathSplitWhereIsflattenis_Dictis_List is_Sequence is_Stringis_Tuple semi_deepcopysemi_deepcopy_dictto_String_for_substuniquer_hashablesc@s eZdZdS)_NullN)__name__ __module__ __qualname__rr0lib/python3.7/site-packages/SCons/Environment.pyrMsrTcCsdS)Nr)envtargetsourcerrr alias_builderYsr AliasBuilder)actiontarget_factorysource_factorymulti is_explicitnamecCsh|dk r||d<|sdSxJdd|DD]8}t|snszapply_tools..)rrTool)rtoolsr(toolZtoolnameZtoolargsrest_rrr apply_toolses r1ZCHANGED_SOURCESZCHANGED_TARGETSZSOURCEZSOURCESZTARGETZTARGETSZUNCHANGED_SOURCESZUNCHANGED_TARGETScCsJt|}x<|D],}|tkrd}tjtjj||||=qW|S)Nz/Ignoring attempt to set reserved variable `$%s')rcopykeysreserved_construction_var_namesSConsWarningswarnReservedVariableWarning)dictresultkmsgrrrcopy_non_reserved_keywordss r=cCsd}tjtjj||dS)Nz/Ignoring attempt to set reserved variable `$%s')r5r6r7r8)rkeyvaluer<rrr _set_reservedsr@cCs(||j|<d}tjtjj||dS)NzM`$%s' will be reserved in a future release and setting it will become ignored)_dictr5r6r7ZFutureReservedVariableWarning)rr>r?r<rrr_set_future_reserveds rBcCsy*|j|}x|D] }||=qWWn(tk rRt||}||j|<YnXx0|D]$\}}tj|s^t dt |q^W| |dS)Nz%s is not a Builder.) rAr2r3KeyError BuilderDictitemsr5BuilderZ is_a_Builderrreprupdate)rr>r?Zbdr;vrrr _set_BUILDERSs   rJcCs|j|=|dS)N)rAscanner_map_delete)rr>rrr _del_SCANNERSsrLcCs||j|<|dS)N)rArK)rr>r?rrr _set_SCANNERSs rMc Cstt}g}|r|xL|D]D}y ||kr>||||Wqtk r^||YqXqW|rp||S)z=Delete duplicates from a sequence, keeping the first or last.)setreverseappendadd TypeError)lZ keep_lastseenr:irrr_delete_duplicatess  rVcsFeZdZdZdeffdd ZddZddZd d Zd d Z Z S) BuilderWrappera A MethodWrapper subclass that that associates an environment with a Builder. This mainly exists to wrap the __call__() function so that all calls to Builders can have their argument lists massaged in the same way (treat a lone argument as the source, treat two arguments as target then source, make sure both target and source are lists) without having to have cut-and-paste code to do it. As a bit of obsessive backwards compatibility, we also intercept attempts to get or set the "env" or "builder" attributes, which were the names we used before we put the common functionality into the MethodWrapper base class. We'll keep this around for a while in case people shipped Tool modules that reached into the wrapper (like the Tool/qt.py module does, or did). There shouldn't be a lot attribute fetching or setting on these, so a little extra work shouldn't hurt. NcsR|tkr|}d}|dk r&t|s&|g}|dk r)rGr')r[rrr__repr__szBuilderWrapper.__repr__cCs|S)N)r_)r[rrr__str__szBuilderWrapper.__str__cCs(|dkr|jS|dkr|jSt|dS)Nrbuilder)objectmethodAttributeError)r[r'rrr __getattr__s zBuilderWrapper.__getattr__cCs.|dkr||_n|dkr ||_n ||j|<dS)Nrra)rbrc__dict__)r[r'r?rrr __setattr__s zBuilderWrapper.__setattr__) rrr__doc__rXrZr_r`rerg __classcell__rr)r^rrWs  rWcsHeZdZdZfddZddZfddZfdd Zd d ZZ S) rDzThis is a dictionary-like class used by an Environment to hold the Builders. We need to do this because every time someone changes the Builders in the Environment's BUILDERS dictionary, we must update the Environment's attributes.cs||_t|dS)N)rrY__init__)r[mappingr)r^rrrjszBuilderDict.__init__cCs tddS)Nz"cannot semi_deepcopy a BuilderDict)rR)r[rrr__semi_deepcopy__szBuilderDict.__semi_deepcopy__csTyt|j|j}Wntk r&YnX|j|t||t|j||dS)N)getattrrrcrd RemoveMethodrY __setitem__rW)r[itemvalrc)r^rrro"s zBuilderDict.__setitem__cst|t|j|dS)N)rY __delitem__delattrr)r[rp)r^rrrr,s zBuilderDict.__delitem__cCs&x |D]\}}|||q WdS)N)rEro)r[rkrUrIrrrrH0szBuilderDict.update) rrrrhrjrlrorrrHrirr)r^rrDs   rDz [_a-zA-Z]\w*$cCs t|S)zNReturn if the specified string is a legitimate construction variable. ) _is_valid_varmatch)Zvarstrrrris_valid_construction_var8srvc@seZdZdZddZddZddZdd Zd d Zd d Z d8ddZ ddZ ddZ ddZ ddZd9ddZeefddZddZdd Zd:d"d#Zd;d$d%Zdd-d.Zd/d0Zd1d2Zed*d3d4Zd?dd*d6d7Z dS)@SubstitutionEnvironmentaeBase class for different flavors of construction environments. This class contains a minimal set of methods that handle construction variable expansion and conversion of strings to Nodes, which may or may not be actually useful as a stand-alone class. Which methods ended up in this class is pretty arbitrary right now. They're basically the ones which we've empirically determined are common to the different construction environment subclasses, and most of the others that use or touch the underlying dictionary of construction variables. Eventually, this class should contain all the methods that we determine are necessary for a "minimal" interface to the build engine. A full "native Python" SCons environment has gotten pretty heavyweight with all of the methods and Tools and construction variables we've jammed in there, so it would be nice to have a lighter weight alternative for interfaces that don't need all of the bells and whistles. (At some point, we'll also probably rename this class "Base," since that more reflects what we want this class to become, but because we've released comments that tell people to subclass Environment.Base to create their own flavors of construction environment, we'll save that for a future refactoring when this class actually becomes useful.) cKsRtjjrt|dtjj|_tjjj |_ tjj |_ | |_|g|_dS)zGInitialization of an underlying SubstitutionEnvironment class. z#Environment.SubstitutionEnvironmentN)r5Debugtrack_instancesrNodeFSget_default_fsfsAlias default_ansansarg2nodes_lookups lookup_listr2rA _init_special added_methods)r[r]rrrrjZs    z SubstitutionEnvironment.__init__cCsni|_t|jd<i|_xtD]}t|j|<qWxtD]}t|j|<q4Wt|jd<t|jd<t |j |_ dS)z[Initial the dispatch tables for special handling of special construction variables.SCANNERSBUILDERSN) _special_delrL _special_setr4r@&future_reserved_construction_var_namesrBrJrMlistr3_special_set_keys)r[r>rrrrfs     z%SubstitutionEnvironment._init_specialcCs |j|jkS)N)rA)r[otherrrr__eq__xszSubstitutionEnvironment.__eq__cCs(|j|}|r|||n|j|=dS)N)rgetrA)r[r>Zspecialrrrrr{s  z#SubstitutionEnvironment.__delitem__cCs |j|S)N)rA)r[r>rrr __getitem__sz#SubstitutionEnvironment.__getitem__cCsL||jkr|j||||n*||jkr>t|s>td|||j|<dS)Nz"Illegal construction variable `%s')rrrArtrur)r[r>r?rrrros  z#SubstitutionEnvironment.__setitem__NcCs|j||S)z*Emulates the get() method of dictionaries.)rAr)r[r>defaultrrrrszSubstitutionEnvironment.getcCs ||jkS)N)rA)r[r>rrr __contains__sz$SubstitutionEnvironment.__contains__cCs |jS)z+Emulates the keys() method of dictionaries.)rAr3)r[rrrr3szSubstitutionEnvironment.keyscCs |jS)z-Emulates the values() method of dictionaries.)rAvalues)r[rrrrszSubstitutionEnvironment.valuescCs |jS)z,Emulates the items() method of dictionaries.)rArE)r[rrrrEszSubstitutionEnvironment.itemscCs|j||S)z1Emulates the setdefault() method of dictionaries.)rA setdefault)r[r>rrrrrsz"SubstitutionEnvironment.setdefaultc Ks |tkr|jj}|tkr|j}|s&gSt|}g}x|D]}t|rd}x|D]}||}|dk rNPqNW|dk rt|rd|d<|j|f|}|r||}t|r||q| |n<|rd|d<||j|f|}t|r||n | |q8| |q8W|S)Nraw) rXr}Filerr rsubstrextendrP) r[r\Z node_factoryrr]nodesrInrSrrr arg2nodess@      z!SubstitutionEnvironment.arg2nodescCs|jS)N)rA)r[rrrgvarsszSubstitutionEnvironment.gvarscCsiS)Nr)r[rrrlvarsszSubstitutionEnvironment.lvarsrc CsD|}|}||d<|r*||tj||||||||S)aRecursively interpolates construction variables from the Environment into the specified string, returning the expanded result. Construction variables are specified by a $ prefix in the string and begin with an initial underscore or alphabetic character followed by any number of underscores or alphanumeric characters. The construction variable names may be surrounded by curly braces to separate the name from trailing characters. __env__)rrrH get_lvarsr5Subst scons_subst) r[stringrrrconvexecutorrrrrrrs zSubstitutionEnvironment.substcCsNi}xD|D]8\}}|||||}t|r>|||||}|||<qW|S)N)rErr)r[r]rrrnkwr;rIrrrsubst_kws z SubstitutionEnvironment.subst_kwc CsD|}|}||d<|r*||tj||||||||S)zbCalls through to SCons.Subst.scons_subst_list(). See the documentation for that function.r)rrrHrr5rscons_subst_list) r[rrrrrrrrrrr subst_lists z"SubstitutionEnvironment.subst_listcCst|s|g}dd}g}xh|D]`}t|rn|j||||d}t|rvt|dkr\|d}qvdtt|}n||}||q W|S)zlSubstitute a path list, turning EntryProxies into Nodes and leaving Nodes (and other objects) as-is.cSs2y |j}Wntk r&t|}YnX|}|S)aThis is the "string conversion" routine that we have our substitutions use to return Nodes, not strings. This relies on the fact that an EntryProxy object has a get() method that returns the underlying Node that it wraps, which is a bit of architectural dependence that we might need to break or modify in the future in response to additional requirements.)rrdr)objrrrrss  z-SubstitutionEnvironment.subst_path..s)rrrrr)rrrlenjoinmaprrP)r[pathrrrrprrr subst_paths   z"SubstitutionEnvironment.subst_path)returncCs|ddl}d|j|jdd}t|s*d|d<tjj||f|}|\}}|}|rdtj d||rxt d||f|S) aEmulate command substitution. Provides behavior conceptually like POSIX Shell notation for running a command in backquotes (backticks) by running ``command`` and returning the resulting output string. This is not really a public API any longer, it is provided for the use of :meth:`ParseFlags` (which supports it using a syntax of !command) and :meth:`ParseConfig`. Raises: OSError: if the external command returned non-zero exit status. rNdevnullT)stdinstdoutstderrZuniversal_newlinesshellrz'%s' exited %d) subprocessPIPErr5ActionZ_subprocZ communicatewaitsysrwriteOSError)r[commandrr]routerrstatusrrrbacktick2s z SubstitutionEnvironment.backtickcCst|||}|j|dS)z Adds the specified function as a method of this construction environment with the specified name. If the name is omitted, the default name is the name of the function itself. N)r rrP)r[functionr'rcrrr AddMethodYs z!SubstitutionEnvironment.AddMethodcsfdd|jD|_dS)z Removes the specified function's MethodWrapper from the added_methods list, so we don't re-bind it when making a clone. csg|]}|jk r|qSr)rc)r)Zdm)rrrr+gsz8SubstitutionEnvironment.RemoveMethod..N)r)r[rr)rrrnbsz$SubstitutionEnvironment.RemoveMethodcCst|s|St|}|s|Si}d}x6|D]*\}}|dkr@|}q*tj|||||<q*Wt||}|rp|||S)a Produce a modified environment whose variables are overridden by the overrides dictionaries. "overrides" is a dictionary that will override the variables of this environment. This function is much more efficient than Clone() or creating a new Environment because it doesn't copy the construction environment dictionary, it just wraps the underlying construction environment, and doesn't even create a wrapper object if there are no overrides. N parse_flags)r=rEr5rscons_subst_onceOverrideEnvironment MergeFlags)r[ overridesoZmergesr>r?rrrrOverrideis   z SubstitutionEnvironment.Overridecsjtdtdtdtdgtdgtdtdggtdgd fddx|D] }|qVWS)aReturn a dict of parsed flags. Parse ``flags`` and return a dict with the flags distributed into the appropriate construction variable names. The flags are treated as a typical set of command-line flags for a GNU-style toolchain, such as might have been generated by one of the {foo}-config scripts, and used to populate the entries based on knowledge embedded in this method - the choices are not expected to be portable to other toolchains. If one of the ``flags`` strings begins with a bang (exclamation mark), it is assumed to be a command and the rest of the string is executed; the result of that evaluation is then added to the dict. r) ASFLAGSCFLAGSCCFLAGSCXXFLAGS CPPDEFINESCPPFLAGSCPPPATH FRAMEWORKPATH FRAMEWORKSLIBPATHLIBS LINKFLAGSRPATHcsR|sdSt|s*x|D] }|qWdS|ddkrH|dd}fdd}t|}d}x|D]}|r|dkr||nH|dkrdj|f}d|n|d krd j|f}d|n|d kr d |f}d|d |n|d kr.d |f}d|n|d krPd |f}d|n|dkrrd|f}d|n`|dkrd|f}d|d |n0|dkrd|f}d|n||d}qj|ddkrdj|qj|dkrd |d }qj|dddkrZ|ddrTd|ddnd}qj|dddkr|ddrd|ddnd}qj|dddkr|ddrЈd|ddnd}qj|dddkrd|ddd|qj|dddkr|dddkrJd |ddnb|dd!d"krtd |d!dn8|dd#d$krd |d#dnd |qj|ddd%krЈd&|qj|ddd'kr|ddr||ddnd}qj|d(krd)}qj|dd*d+krBd,|d*dqj|ddd-kr|ddrzd,|ddnd,}qj|d.krd|d |qj|d/krˆd |qj|dd0d1krd2|d0dkrd3}nd4}||qj|dd5kr,d|d |qj|d6kr<|}qjd|qjWdS)7Nr!rcSsN|d}t|dkr&|d|n$|d|dd|ddgdS)N=rrr)splitrrPr)r'rktrrr append_defines  zKSubstitutionEnvironment.ParseFlags..do_parse..append_definerz-includerz-imacrosz -isysrootrz-isystemz-iquotez -idirafterz-archz--param)-+rz -dylib_filez-Lrz-lz-Irz-Wa,rz-Wl, z -Wl,-rpath=rz-Wl,-R,z-Wl,-Rz-Wp,rz-Dz -frameworkrz-frameworkdir=rz-F)z -mno-cygwinz-pthreadz-openmpz-fmerge-all-constantsz-fopenmpz -mwindowsz-std=z++rrr)z-includez-imacrosz -isysrootz-isystemz-iquotez -idirafterz-archz--param)rrshlexrr}rrP)argrrZparamsZappend_next_arg_tor>)do_parserkr[rrrs               z4SubstitutionEnvironment.ParseFlags..do_parse)r)r[flagsrr)rrkr[r ParseFlagss$  z"SubstitutionEnvironment.ParseFlagsTc CsTt|s||}|s&|jf|dSx&|D]\}}|sBq2t|}y ||}Wntk rn|}YnnX|sz|}nb|ry ||}WnPttfk ry |j}Wn$tk r| d||}Yn X||YnXg}|dddkrxP|D]}||kr||qWn0x.|dddD]}||kr$| d|q$W|||<q2WdS)a Merge flags into construction variables. Merges the flags from ``args`` into this construction environent. If ``args`` is not a dict, it is first converted to one with flags distributed into appropriate construction variables. See :meth:`ParseFlags`. Args: args: flags to merge unique: merge flags rather than appending (default: True). When merging, path variables are retained from the front, other construction variables from the end. NrPATH) rrAppendrEr rCrRrPrdinsert) r[r\uniquer>r?orig add_to_origrrIrrrrEsD          z"SubstitutionEnvironment.MergeFlags)N)N)rNNNN)rNN)rNNNN)NN)N)T)!rrrrhrjrrrrrrorrr3rrErrXrrrrrrrsubst_target_sourcestrrrrnrr9rrrrrrrw@s8   +  '' BrwcCstjj}|||||S)N)r5DefaultsDefaultEnvironment decide_source) dependencyrprev_ni repo_nodefrrrdefault_decide_sources rcCstjj}|||||S)N)r5rr decide_target)rrrrrrrrdefault_decide_targets rcCstjj|||S)N)r5CacheDirZcopy_from_cache)rsrcdstrrrdefault_copy_from_cachesrcCstjj|||S)N)r5rZ copy_to_cache)rrrrrrdefault_copy_to_cachesrc@seZdZdZdddZddZdddZd d Zdd d Ze j j ddZ ddZ dddZddZddZddZddZddZddZd ejd!fd"d#Zdd$d%Zgddfd&d'Zdd(d)Zdd*d+Zdd,d-Zdd.d/Zdd0d1Zdd2d3Zd4d5Z d6d7Z!d8d9Z"dd;d<Z#d=d>Z$dd@dAZ%ddBdCZ&dDdEZ'dFdGZ(d ejd?fdHdIZ)ddJdKZ*dLdMZ+dNdOZ,dPdQZ-dRdSZ.de j/j/dTdUdVZ/ddWdXZ0dYdZZ1d[d\Z2d]d^Z3gdfd_d`Z4dadbZ5dcddZ6ddedfZ7dgdhZ8didjZ9dkdlZ:dmdnZ;dodpZdudvZ?dwdxZ@dydzZAd{d|ZBd}d~ZCddZDddZEddZFdddZGddZHddZIddZJddZKddZLddZMddZNddZOe jPQdfddZRddZSddZTdddZUdddZVdddZWddZXdS)BaseaABase class for "real" construction Environments. These are the primary objects used to communicate dependency and construction information to the build engine. Keyword arguments supplied when the construction Environment is created are construction variables used to initialize the Environment. Nc Ks&tjjrt|di|_tjj|_tjj j |_ tjj |_ ttjj|_|g|_t|_t|_d|_t|jd||jd<|dkr|jdd}|dkrtj}t|rtj|}t||jd<|||jdd|jd<|jdd|jd<|jdd|jd<|jd d|jd <d |kr:|d }|d =|jf|t| }|rr|t| }|!|i}x8|D]0} y|j| || <Wnt"k rYnXq|Wtj#$||dkr|jd d}|dkrd g}t%|||x |&D]\} } | |j| <qW|r"|'|dS) aInitialization of a basic SCons construction environment. Sets up special construction variables like BUILDER, PLATFORM, etc., and searches for and applies available Tools. Note that we do *not* call the underlying base class (SubsitutionEnvironment) initialization, because we need to initialize things in a very specific order that doesn't work with the much simpler base class initialization. zEnvironment.BaseFrNPLATFORMZHOST_OSZ HOST_ARCHZ TARGET_OSZ TARGET_ARCHZoptionsZTOOLSr)(r5rxryr_memorzr{r|r}r~rrrrrrZConstructionEnvironmentrArrrrrrcache_timestamp_newerrDrPlatformrrReplacerr3ZUpdaterCr,Z Initializersr1rEr) r[platformr-r(Z variablesrr]r3Zsaver;r>rqrrrrjsb               z Base.__init__cCs(y|jd|Stk r"dSXdS)zHFetch the builder with the specified name from the environment. rN)rArC)r[r'rrr get_builderszBase.get_buildercCs:|dkr|dtjj}t|tjjs6tdt||S)zValidate the passed custom CacheDir class, or if no args are passed, validate the custom CacheDir class from the environment. NCACHEDIR_CLASSz2Custom CACHEDIR_CLASS %s not derived from CacheDir)rr5r issubclassrr)r[ custom_classrrrvalidate_CacheDir_classs zBase.validate_CacheDir_classcCsy |j}Wn tk r*tjj}YnX|}y"||jkrTt|j|krT|jSWntk rjYnX||}||_||_|S)N) _CacheDir_pathrdr5rrrZ_last_CacheDir_pathtypeZ_last_CacheDir)r[rZcachedir_classZcdrrr get_CacheDir*s   zBase.get_CacheDirrcCsj|}yt|tjjj}Wntk r,Yn*X|rVy |j}Wntk rPYnXd}|sft|j |}|S)z`Return a factory function for creating Nodes for this construction environment. N) rr5rzr{rrRrrdrmr})r[factoryrr'Zis_noderrr get_factoryAs  zBase.get_factorycCsy |jdStk rYnXi}y|jd}Wntk rFYnhXt|sX|g}n |dd}|x@|D]8}x2||D]$}|r|ddkr|}|||<qWqrW||jd<|S)N_gsmrrwin32)r rCrArrOZ get_skeyslower)r[r:Zscannersscannerr;rrrr^s(    z Base._gsmcCs&|r|ddkr|}||S)zJFind the appropriate scanner given a key (usually a file suffix). rr)rrr)r[Zskeyrrr get_scannerszBase.get_scannercCs&y |jd=Wntk r YnXdS)z7Delete the cached scanner map (if we need to). rN)r rC)r[r]rrrrKs zBase.scanner_map_deletecCs|j|dS)zPrivate method to update an environment's consvar dict directly. Bypasses the normal checks that occur when users try to set items. N)rArH)r[rrrr_updatesz Base._updatecCs.x(|D]\}}||jkr ||j|<q WdS)a,Private method to add new items to an environment's consvar dict. Only adds items from `other` whose keys do not already appear in the existing dict; values from `other` are not used for replacement. Bypasses the normal checks that occur when users try to set items. N)rErA)r[rr;rIrrr_update_onlynews zBase._update_onlynewcCs2y|jStk r,tjj}||_|SXdS)N)Z src_sig_typerdr5rr)r[rrrrget_src_sig_types  zBase.get_src_sig_typecCs2y|jStk r,tjj}||_|SXdS)N)Z tgt_sig_typerdr5rr)r[rrrrget_tgt_sig_types  zBase.get_tgt_sig_typec Ks*t|}x|D]\}}y6|dkrHt|j|rH|j|g|j|<|j|}Wn>tk r|dkrt|r|g|j|<n ||j|<wYnXy |j}Wntk r0y|||j|<Wnfttfk r(y |j}Wn2tk r|r| d|||j|<YnX|r$||YnXwYnXt |r|dkrg}x<|D]0\}} | dk rv||| fn ||fqTW|}||7}||j|<nxv|D]} d|| <qWqy ||Wqttt fk rt |r x(|D]\}} | ||<qWnd||<YqXqW| |dS)zAppend values to construction variables in an Environment. The variable is created if it is not already present. rrN)r=rErrArCrHrdrRrPrr ValueErrorrrK) r[r]r>rqr update_dictrtmpr;rIrrrrs\           z Base.AppendcCs4t|st|}|r0|ddkr0t|j|}|S)zzAllow Dirs and strings beginning with # for top-relative. Note this uses the current env's fs (in self). r#)rrr}Dir)r[rrrr _canonicalize s zBase._canonicalizeENVFcCsdd}||jkr*||j|kr*|j||}t|||||jd}||jkrRi|j|<||j||<dS)aAppend path elements to the path *name* in the *envname* dictionary for this environment. Will only add any particular path once, and will normpath and normcase all paths to help assure this. This can also handle the case where the env variable is a list instead of a string. If *delete_existing* is False, a *newpath* element already in the path will not be moved to the end (it will be left where it is). r) canonicalizeN)rArr&)r[r'newpathenvnamesepdelete_existingrnvrrr AppendENVPaths   zBase.AppendENVPathc  st|}x|D]\}tr0t|||jksH|j|dkrT|j|<qt|j|r|tr||j|qtr>|j||dkrg}xjD]b}t|rt|dkr||d|dfn||dfqt |r||q||fqW|tr`g}x<D]0\}}|dk rH|||fn ||fq&W|nt rtfgn|g}xrD]j}t|rt|dkr||d|dfn||dfn"t |r||n ||fq~W|ntsg|rfddDnfd dD|j|<q|j|tr|dkrg}xrD]j}t|rt|dkr||d|dfn||dfn"t |r||n ||fqfW|tr*g}x<D]0\}}|dk r|||fn ||fqW|nt r<fg|rht t fd d |j|<n fd dD|j|<nH|rt t fd d g|j|<nkrֈg|j|<q|dkrt rgnPtr@g}x<D]0\}}|dk r*|||fn ||fqW|t rbkrZgngnNtrg}x:D].\}}|dk r|||fn ||qzW||rȇfddD|j|<qW| |dS)zAppend values to existing construction variables in an Environment, if they're not already there. If delete_existing is True, removes existing values first, so values move to end. )rNrrrrNcsg|]}|kr|qSrr)r)x)rqrrr+fsz%Base.AppendUnique..csg|]}|kr|qSrr)r)r/)dkrrr+hscSs||kS)Nr)r/rqrrrz#Base.AppendUnique..csg|]}|kr|qSrr)r)r/)rqrrr+scSs||kS)Nr)r/rqrrrr1r2csg|]}|kr|qSrr)r)r/)rqrrr+s)r=rErrVrArrHrrPrrrfilterrK) r[r,r]r>r#rUr;rIjr)r0rqr AppendUnique-s                                    zBase.AppendUniquec Ks|jdi}t|}t|jdg|_t|||jd<g|_x0|jD]&}|t||jkrF|j| |qFWi|_ t |}i}x(| D]\} } t j| || || <qW|jf|t||||jf||r||t jjrt|d|S)amReturn a copy of a construction Environment. The copy is like a Python "deep copy"--that is, independent copies are made recursively of each objects--except that a reference is copied when an object is not deep-copyable (like a function). There are no references to any mutable objects in the original Environment. rzEnvironment.EnvironmentClone)rArr2rrDrrmr'rPcloner r=rEr5rrr r1rrxryr) r[r-r(rr]Zbuildersr6Zmwnewr>r?rrrClones*        z Base.ClonecCs"||||rdS|||||S)Nr)Z changed_stater)r[rrrrrrr_changed_buildszBase._changed_buildcCs||||S)N)Zchanged_content)r[rrrrrrr_changed_contentszBase._changed_contentcCs<|}|}|dkr(|||||S|||||SdS)Nr)Z get_build_envr rr)r[rrrrZ target_envrrrr_changed_sources zBase._changed_sourcecCs||||S)N)Zchanged_timestamp_then_content)r[rrrrrrr_changed_timestamp_then_contentsz$Base._changed_timestamp_then_contentcCs||||S)N)Zchanged_timestamp_newer)r[rrrrrrr_changed_timestamp_newerszBase._changed_timestamp_newercCs||||S)N)Zchanged_timestamp_match)r[rrrrrrr_changed_timestamp_matchszBase._changed_timestamp_matchcCstd|_|dkr|j}nN|dkr&|j}n>|dkr<|j}d|_n(|dkrL|j}nt|sdtdt|||_||_ dS)NF)ZMD5Zcontent)z MD5-timestampzcontent-timestamp)ztimestamp-newerZmakeTztimestamp-matchzUnknown Decider value %s) r r:r<r=r>callablerrGrr)r[rrrrDecidersz Base.DecidercCs2t|s|g}x|D]}||}|r|SqWdS)zReturn the first available program from one or more possibilities. Args: progs (str or list): one or more command names to check for N)rr )r[ZprogsprogrrrrDetects  z Base.Detectcs4|s jSfdd|D}t|dkr0|d}|S)aReturn construction variables from an environment. Args: \*args (optional): variable names to look up Returns: If `args` omitted, the dictionary of all construction variables. If one arg, the corresponding value is returned. If more than one arg, a list of values is returned. Raises: KeyError: if any of `args` is not in the construction environment. csg|]}j|qSr)rA)r)r/)r[rrr+1sz#Base.Dictionary..rr)rAr)r[r\dlistr)r[r Dictionary s  zBase.Dictionaryprettyc Cs~|r||}n|}|}|dkrFddl}|jdd}||S|dkrnddl}dd}|j|d |d Std |dS) a Return construction variables serialized to a string. Args: key (optional): if None, format the whole dict of variables. Else format the value of `key` (Default value = None) format (str, optional): specify the format to serialize to. `"pretty"` generates a pretty-printed string, `"json"` a JSON-formatted string. (Default value = `"pretty"`) rErNr)indentjsoncSstt|jS)N)rrr)rrrrnon_serializableWsz#Base.Dump..non_serializabler)rFrz%Unsupported serialization format: %s.)rDrpprintZ PrettyPrinterZpformatrGdumpsr!) r[r>formatZcvarsZfmtrIZpprGrHrrrDump7s    z Base.DumpcCsl|d|}|d|}xJ|D]B}tjt|}|dt||kr"|t| d|kr"|Sq"WdS)a)Search a list of paths for something that matches the prefix and suffix. Args: paths: the list of paths or nodes. prefix: construction variable for the prefix. suffix: construction variable for the suffix. Returns: the matched path or None $N)rosrbasenamerr)r[pathsprefixsuffixrr'rrrFindIxes^s  *z Base.FindIxesTcCsF|dkr|fdd}|}t|r*d|}||}|||||S)atParse the result of running a command to update construction vars. Use ``function`` to parse the output of running ``command`` in order to modify the current environment. Args: command: a string or a list of strings representing a command and its arguments. function: called to process the result of ``command``, which will be passed as ``args``. If ``function`` is omitted or ``None``, :meth:`MergeFlags` is used. Takes 3 args ``(env, args, unique)`` unique: whether no duplicate values are allowed (default true) NcSs |||S)N)r)rcmdrrrr parse_confsz$Base.ParseConfig..parse_conf )rrrr)r[rrrrUrrr ParseConfigss   zBase.ParseConfigc Cs||}y&t|d}t|}WdQRXWntk rJ|rFdSXdd|D}g}xP|D]H}y|dd\}} Wnttfk rYqdX||| fqdW|rg} x|D]} | | dqWt | dkrt d|| fx|D]\}} | || qWdS) a Parse a mkdep-style file for explicit dependencies. This is completely abusable, and should be unnecessary in the "normal" case of proper SCons configuration, but it may help make the transition from a Make hierarchy easier for some people to swallow. It can also be genuinely useful when using a tool that can write a .d file, but for which writing a scanner would be too complicated. rNcSsg|]}|ddkr|qS)rr$r)r)rSrrrr+sz%Base.ParseDepends..:rrz2More than one dependency target found in `%s': %s) ropenr readlinesIOErrorrrdr!rPrrrDepends) r[filenameZ must_existZonly_onefplinesZtdlistlinerZdependstargetsZtdrrr ParseDependss4      zBase.ParseDependscCs||}tj||S)N)rr5r )r[r rrrr s z Base.Platformc Kstt|}xZ|D]L\}}y|j|}Wn tk rL||j|<wYnXy |j}Wntk ry|||j|<Wn^ttfk ry |j}Wn$tk r|r|d|YnX|r||||j|<YnXwYnXt |rxt|D] }d||<qWqy ||Wqttt fk r`t |rTx(|D]\}}|||<qrqrr"Z add_to_valrIr;rrrPrependsB       z Base.PrependcCsdd}||jkr*||j|kr*|j||}t|||||jd}||jkrRi|j|<||j||<dS)aPrepend path elements to the path *name* in the *envname* dictionary for this environment. Will only add any particular path once, and will normpath and normcase all paths to help assure this. This can also handle the case where the env variable is a list instead of a string. If *delete_existing* is False, a *newpath* component already in the path will not be moved to the front (it will be left where it is). r)r(N)rAr r&)r[r'r)r*r+r,rr-rrrPrependENVPaths     zBase.PrependENVPathc sjt|}xP|D]B\}tr2t| ||jksJ|j|dkrV|j|<qt|j|r~tr~|j|qtr|j|tsg|rfddDnfddD|j|<q|j|tr2|rfddDg|j|<nkrXg|j|<q|rJfddD|j|<qW||dS)zPrepend values to existing construction variables in an Environment, if they're not already there. If delete_existing is True, removes existing values first, so values move to front. )rNcsg|]}|kr|qSrr)r)r/)rqrrr+%sz&Base.PrependUnique..csg|]}|kr|qSrr)r)r/)r0rrr+'scsg|]}|kr|qSrr)r)r/)rqrrr+/scsg|]}|kr|qSrr)r)r/)rqrrr+6sN)r=rErrVrArrHrK)r[r,r]r>r)r0rqr PrependUniques6      zBase.PrependUniquecKsby |d}Wntk r YnXt||}|d=|d|t|}|t|||dS)zyReplace existing construction variables in an Environment with new construction variables and/or values. rN)rCrDror=rrrK)r[r]Zkwbdrrrr :s   z Base.ReplacecCs|d|}|d|}|d|}|d|}tjt|\}}|dt||krp|t|d}|t| d|kr|dt| }tj||||S)a Replace old_prefix with new_prefix and old_suffix with new_suffix. env - Environment used to interpolate variables. path - the path that will be modified. old_prefix - construction variable for the old prefix. old_suffix - construction variable for the old suffix. new_prefix - construction variable for the new prefix. new_suffix - construction variable for the new suffix. rMN)rrNrrrrr)r[rZ old_prefixZ old_suffixZ new_prefixZ new_suffixdirr'rrr ReplaceIxesJs zBase.ReplaceIxescKs6x$t|D]}||jkr||=qW|jf|dS)N)rr3rAr )r[r]r;rrr SetDefaultbs  zBase.SetDefaultcCs|j||S)N)r}r%rsrcnodeZ get_abspath)r[tprrr_find_toolpath_dirhszBase._find_toolpath_dir)rcKsTt|rH||}|dkr&|dg}tt|j|}tjj||f|}|||S)Nr()rrrrrrkr5r,)r[r.r(kwargsrrrr,ks  z Base.ToolcCs|sdS|dkr8y|dd}WqJtk r4YqJXnt|rJ||}|dkrzy|dd}Wqtk rvYqXnt|r||}t||}t|d|||}|r|SdS)zFind prog in the path. Nr'rZPATHEXTr)rCrrrr )r[rArZpathextZrejectrrrr us*  z Base.WhereIscOs2|fdd}tt||}||}tjj||S)NcSst|r||}|S)N)rr)ar[rrr subst_strings z!Base.Action..subst_string)rrrr5r)r[r\r]rnnargsrrrrrs  z Base.ActioncCs`|||jj}tj|}i}xdd|DD] }d||<q0Wx|D]}||qJW|S)NcSsg|] }|qSr) get_executor)r)rrrrr+sz%Base.AddPreAction..r)rr}Entryr5rr3Zadd_pre_action)r[filesr"runiqrrrr AddPreActions  zBase.AddPreActioncCs`|||jj}tj|}i}xdd|DD] }d||<q0Wx|D]}||qJW|S)NcSsg|] }|qSr)rp)r)rrrrr+sz&Base.AddPostAction..r)rr}rqr5rr3Zadd_post_action)r[rrr"rrsrrrr AddPostActions  zBase.AddPostActionc Ks|||jj}t|s|g}dd|D}|sj|s8|Sg}x(|D] }|t}|||||qBW|S||} | t j ||j j dddt j j f| }g}xf|D]^}|} | dks| tkr|} n| j|| d<t j j f| } ||| |||j|qW|S)NcSsg|] }|r|qSrr)r)r*rrrr+szBase.Alias..r)r"r$r%r&r")rrr~rrr!rrrHr5rr}rqrFr"Zconvertsources) r[rrr"r]tlistr:rbldrbrrrr~s:      z Base.AliascGsBg}x"|D]}||||jjq Wx|D] }|q.W|S)N)rrr}rqZset_always_build)r[rarwrrrr AlwaysBuilds    zBase.AlwaysBuildcKs||}tjjf|S)N)rr5rF)r[r]rrrrrFs z Base.BuildercCs>|dk r||}||_|r*|||d<tjjr:|dS)Nr)rrrr5rZexecute_actionsr)r[rrrrrrs z Base.CacheDirc Csb|||jj}|||jj}x<|D]4}yt||Wq&tk rX|t|<Yq&Xq&WdS)N)rr}rq CleanTargetsrrC)r[rarrrwZflistrrrrCleans z Base.CleancOst|g}|r|||d}||}|ddd|d<y||d|d<Wntk rdYnXtjj||S)NrZ_depthrZ custom_tests)rrrrCr5ZSConf)r[r\r]rorrrr Configure s zBase.ConfigurecKs||jj|jjd}y|d|d<Wntk r8YnX|d=y|d|d<Wntk rdYnX|d=y|d|d<Wntk rYnX|d=y|d|d<Wntk rYnX|d=tjjf|}||||f|S)zBuilds the supplied target files from the supplied source files using the supplied action. Action may be any type that the Builder constructor will accept for an action.)r"r#r$Zsource_scannerZtarget_scannerr$r#)r}rqrCr5rF)r[rrr"r]ZbkwrxrrrCommands2 z Base.CommandcCs<|||jj}|||jj}x|D]}||q&W|S)z8Explicity specify that 'target's depend on 'dependency'.)rr}rqZadd_dependency)r[rrrwrCrrrrr\Es  z Base.DependscOsV||}t|rBg}x&|D]}||jj|f||qW|S|jj|f||S)z )rrrPr}r%)r[r'r\r]rr:errrr%Ms  zBase.DircCsF||}t|r:g}x|D]}||j|qW|S|j|S)N)rrrPr} PyPackageDir)r[Z modulenamerr:rrrrrXs  zBase.PyPackageDircGsBg}x"|D]}||||jjq Wx|D] }|q.W|S)z2Tags a target so that it will not be cleaned by -c)rrr}rqZ set_noclean)r[rarwrrrrNoCleanas    z Base.NoCleancGsBg}x"|D]}||||jjq Wx|D] }|q.W|S)z+Tags a target so that it will not be cached)rrr}rqZ set_nocache)r[rarwrrrrNoCachejs    z Base.NoCachecOsV||}t|rBg}x&|D]}||jj|f||qW|S|jj|f||S)z )rrrPr}rq)r[r'r\r]rr:rrrrrqss  z Base.EntrycKstjjf||S)N)r5 Environmentr)r[r]rrrr~szBase.EnvironmentcOs`|j|f||}|gg|}t|trX|j}|jrB|jd|}tjd||jS|SdS)z:Directly execute an action through an Environment z: zscons: *** %s N) r isinstancererrstrr]rrrr)r[r"r\r]r:rrrrExecutes  z Base.ExecutecOsV||}t|rBg}x&|D]}||jj|f||qW|S|jj|f||S)z )rrrPr}r)r[r'r\r]rr:rrrrrs  z Base.FilecCs.||}|||jj}tjj|t|S)N) rrr}r%r5rzr{Z find_filetuple)r[filedirsrrrrFindFiles z Base.FindFilecCst|S)N)r )r[ZsequencerrrFlattensz Base.FlattencCs2ttt|||jj}t|r&|S|dSdS)Nr)rrrrr}rqr)r[rrr:rrr GetBuildPathszBase.GetBuildPathcCs|j||||||S)N)r}Globr)r[patternZondiskrZstringsZexcluderrrrsz Base.GlobcCs<|||jj}|||jj}x|D]}||q&W|S)zIgnore a dependency.)rr}rqZ add_ignore)r[rrrwrCrrrrIgnores  z Base.IgnorecCs tj|S)N)r5rLiteral)r[rrrrrsz Base.LiteralcGsdg}xZ|D]R}t|tjjr0|||q x*|||jjD]}|||qBWq W|S)N)rr5rzZ set_localrPrr}rq)r[raZretZtargrrrrLocals  z Base.LocalcGsBg}x"|D]}||||jjq Wx|D] }|q.W|S)N)rrr}rqZ set_precious)r[rarwrrrrPreciouss    z Base.PreciouscGsBg}x"|D]}||||jjq Wx|D] }|q.W|S)N)rrr}rqZ set_pseudo)r[rarwrrrrPseudos    z Base.PseudocOs&|t||jj}|jj||dS)N)rrr}r% Repository)r[rr]rrrrszBase.RepositorycCs<|||jj}|||jj}x|D]}||q&W|S)zSpecify that 'prerequisite' must be built before 'target', (but 'target' does not actually depend on 'prerequisite' and need not be rebuilt if it changes).)rr}rqZadd_prerequisite)r[rZ prerequisiterwZplistrrrrRequiress  z Base.RequirescOsFg}x(|D] }t|r ||}||q W||}tjj||S)N)rrrPrr5ScannerZ ScannerBase)r[r\r]rorrrrrrs   z Base.ScannercCs|dk r4||}tj|s4tjt|jj|}|rrtj|}tj |}|rrtj |sr| t j |t j||dS)N)rrNrisabsrrr}ZSConstruct_dirnormpathdirnameexistsrr5rZMkdirSConsignr)r[r'Z dbm_moduleZ sconsign_dirrrr SConsignFiles    zBase.SConsignFilecCs|||jj}|||jj}g}xx|D]p}|rFtdt|||d|_||d}x&|D]}||j krj|j |d}qjW|r*| |q*W|S)zSTell scons that side_effects are built as side effects of building targets.z=Multiple ways to build the same target were specified for: %srFT) rr}rqZ multiple_side_effect_has_builderrrZ add_source side_effectr side_effectsrP)r[rrrraZadded_side_effectsZaddedrrr SideEffects"      zBase.SideEffectcCs>t|rtt|j|St|r.||S||gSdS)aSThis function converts a string or list into a list of strings or Nodes. This makes things easier for users by allowing files to be specified as a white-space separated list to be split. The input rules are: - A single string containing names separated by spaces. These will be split apart at the spaces. - A single Node instance - A list containing either strings or Node instances. Any strings in the list are not split at spaces. In all cases, the function returns a list of Nodes and strings.N)rrrrrr)r[rrrrr s z Base.SplitcCstjj|||S)z )r5rzPythonZ ValueWithMemo)r[r?Z built_valuer'rrrValue! sz Base.ValuercCs<|||jjd}|||jjd}|j|||dS)Nr)rr}r% VariantDir)r[Z variant_dirZsrc_dirZ duplicaterrrr& szBase.VariantDir.csT|||jjd}gfdd|dd}tt|ttS)z- returns a list of all source files. rcsbx\|D]T}t|tjjjr(|q|r<|jqt|tjjj r |qWdS)N) rr5rzr{r% all_childrenZ has_builderrvZ disambiguaterrP)Zssr) build_sourcervrrr1 s  z*Base.FindSourceFiles..build_sourcecSsx||kr|}qW|S)N)ri)noderrr final_source; s z*Base.FindSourceFiles..final_source)rr}rqrrrrN)r[rrr)rrvrFindSourceFiles+ s zBase.FindSourceFilescCs(ddlm}|jdkr"t|j|_|jS)zO returns the list of all targets of the Install and InstallAs Builder. r)installN) SCons.ToolrZ_UNIQUE_INSTALLED_FILESrZ_INSTALLED_FILES)r[rrrrFindInstalledFilesC s   zBase.FindInstalledFiles)NNNNN)N)r)N)F)N)N)N)N)N)N)NrE)NT)NF)F)N)NNN)N)TFFN)NN)r)r)Yrrrrhrjrrrrr5ZMemoizeZCountMethodCallrrrKrrrr rr&rNpathsepr.r5r8r9r:r;r<r=r>r@rBrDrLrSrWrbr rcrdrer rgrhrkr,r rrtrur~rzrFrr|r}r~r\r%rrrrqrrrrrrrrrrrrrrrrZcurrent_sconsign_filenamerrr rrrrrrrrrs  b  !  Q  0       '  (A (    5   -              rc@seZdZdZd'ddZddZddZd d Zd d Zd dZ d(ddZ ddZ ddZ ddZ ddZddZd)ddZddZdd Zd!d"Zd#d$Zd%d&ZdS)*ra$A proxy that overrides variables in a wrapped construction environment by returning values from an overrides dictionary in preference to values from the underlying subject environment. This is a lightweight (I hope) proxy that passes through most use of attributes to the underlying Environment.Base class, but has just enough additional methods defined to act like a real construction environment with overridden values. It can wrap either a Base construction environment, or another OverrideEnvironment, which can in turn nest arbitrary OverrideEnvironments... Note that we do *not* call the underlying base class (SubsitutionEnvironment) initialization, because we get most of those from proxying the attributes of the subject construction environment. But because we subclass SubstitutionEnvironment, this class also has inherited arg2nodes() and subst*() methods; those methods can't be proxied because they need *this* object's methods to fetch the values from the overrides dictionary. NcCs>tjjrt|d||jd<|dkr0i|jd<n ||jd<dS)NzEnvironment.OverrideEnvironment __subjectr)r5rxryrrf)r[subjectrrrrrja s    zOverrideEnvironment.__init__cCs,t|jd|}t|tr$||S|SdS)Nr)rmrfrr r6)r[r'attrrrrrej s  zOverrideEnvironment.__getattr__cCst|jd||dS)Nr)setattrrf)r[r'r?rrrrgy szOverrideEnvironment.__setattr__cCs4y|jd|Stk r.|jd|SXdS)Nrr)rfrCr)r[r>rrrr} szOverrideEnvironment.__getitem__cCs&t|std|||jd|<dS)Nz"Illegal construction variable `%s'r)rvrrf)r[r>r?rrrro s zOverrideEnvironment.__setitem__cCsfy|jd|=Wntk r(d}YnXd}y|jd|}Wntk r`|sXd}YnX|S)Nrrrr)rfrCrr)r[r>Zdeletedr:rrrrr s  zOverrideEnvironment.__delitem__cCs6y|jd|Stk r0|jd||SXdS)z*Emulates the get() method of dictionaries.rrN)rfrCr)r[r>rrrrr szOverrideEnvironment.getcCs ||jdkrdS||jdkS)NrTr)rf)r[r>rrrr sz OverrideEnvironment.__contains__csT|jd|jd|s*Sfdd|D}t|dkrP|d}|S)Nrrcsg|] }|qSrr)r)r/)drrr+ sz2OverrideEnvironment.Dictionary..rr)rfrDr2rHr)r[r\rCr)rrrD s zOverrideEnvironment.DictionarycCs |S)z,Emulates the items() method of dictionaries.)rDrE)r[rrrrE szOverrideEnvironment.itemscCs |S)z+Emulates the keys() method of dictionaries.)rDr3)r[rrrr3 szOverrideEnvironment.keyscCs |S)z-Emulates the values() method of dictionaries.)rDr)r[rrrr szOverrideEnvironment.valuescCs2y ||Stk r,||jd|<|SXdS)z1Emulates the setdefault() method of dictionaries.rN)rrCrf)r[r>rrrrr s  zOverrideEnvironment.setdefaultcCs|jd|dS)Nr)rfrH)r[rrrrr szOverrideEnvironment._updatecCs6x0|D]$\}}||jdkr ||jd|<q WdS)zUpdate a dict with new keys. Unlike the .update method, if the key is already present, it is not replaced. rN)rErf)r[rr;rIrrrr sz#OverrideEnvironment._update_onlynewcCs|jdS)Nr)rfr)r[rrrr szOverrideEnvironment.gvarscCs"|jd}||jd|S)Nrr)rfrrH)r[rrrrr szOverrideEnvironment.lvarscKs t|}|jdt|dS)Nr)r=rfrHr)r[r]rrrr  szOverrideEnvironment.Replace)N)N)N)rrrrhrjrergrrorrrrrDrEr3rrrrrrr rrrrrL s&     rcCsGdddt}||S)a An entry point for returning a proxy subclass instance that overrides the subst*() methods so they don't actually perform construction variable substitution. This is specifically intended to be the shim layer in between global function calls (which don't want construction variable substitution) and the DefaultEnvironment() (which would substitute variables if left to its own devices). We have to wrap this in a function that allows us to delay definition of the class until it's necessary, so that when it subclasses Environment it will pick up whatever Environment subclass the wrapper interface might have assigned to SCons.Environment.Environment. c@sTeZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ dS)z1NoSubstitutionProxy.._NoSubstitutionProxycSs||jd<dS)Nr)rf)r[rrrrrj sz:NoSubstitutionProxy.._NoSubstitutionProxy.__init__cSst|jd|S)Nr)rmrf)r[r'rrrre sz=NoSubstitutionProxy.._NoSubstitutionProxy.__getattr__cSst|jd||S)Nr)rrf)r[r'r?rrrrg sz=NoSubstitutionProxy.._NoSubstitutionProxy.__setattr__cSs,d|kr |d|d<|d=ni|d<dS)Nrr)r)r[Zkwdictrrrexecutor_to_lvars szCNoSubstitutionProxy.._NoSubstitutionProxy.executor_to_lvarscSs4y |d}Wntk r YnX|d=||d<dS)Nrmode)rC)r[rkrrrr raw_to_mode s  z=NoSubstitutionProxy.._NoSubstitutionProxy.raw_to_modec_s|S)Nr)r[rr\rlrrrr sz7NoSubstitutionProxy.._NoSubstitutionProxy.substc_s|S)Nr)r[r]r\rlrrrr sz:NoSubstitutionProxy.._NoSubstitutionProxy.subst_kwc_s>||f|}|}i|d<||||tjj||S)Nr)r2rrr5rr)r[rr\rlrorrrrr s    z._NoSubstitutionProxy.subst_listc_s>||f|}|}i|d<||||tjj||S)Nr)r2rrr5rr)r[rr\rlrorrrrr s    zENoSubstitutionProxy.._NoSubstitutionProxy.subst_target_sourceN) rrrrjrergrrrrrrrrrr_NoSubstitutionProxy s r)r)rrrrrNoSubstitutionProxy s0r)N)N)Urhr2rNrrer collectionsrZ SCons.Actionr5Z SCons.BuilderZ SCons.DebugrZSCons.DefaultsZ SCons.ErrorsrrZ SCons.MemoizeZ SCons.NodeZSCons.Node.AliasZ SCons.Node.FSZSCons.Node.PythonZSCons.PlatformZ SCons.SConfZSCons.SConsignZ SCons.SubstrZSCons.WarningsZ SCons.Utilrrrr r r r r rrrrrrrrrrrXZ_warn_copy_deprecatedZ"_warn_source_signatures_deprecatedZ"_warn_target_signatures_deprecatedr{ZCalculatorArgsr rFrzr~rr{rqr!r1r4rr=r@rBrJrLrMrVrWrDcompilertrvrwrrrrrrrrrrrrs  L   ">% H  A