905 lines
34 KiB
Python
905 lines
34 KiB
Python
|
"""SCons.Subst
|
||
|
|
|
||
|
|
SCons string substitution.
|
||
|
|
|
||
|
|
"""
|
||
|
|
|
||
|
|
#
|
||
|
|
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 The SCons Foundation
|
||
|
|
#
|
||
|
|
# Permission is hereby granted, free of charge, to any person obtaining
|
||
|
|
# a copy of this software and associated documentation files (the
|
||
|
|
# "Software"), to deal in the Software without restriction, including
|
||
|
|
# without limitation the rights to use, copy, modify, merge, publish,
|
||
|
|
# distribute, sublicense, and/or sell copies of the Software, and to
|
||
|
|
# permit persons to whom the Software is furnished to do so, subject to
|
||
|
|
# the following conditions:
|
||
|
|
#
|
||
|
|
# The above copyright notice and this permission notice shall be included
|
||
|
|
# in all copies or substantial portions of the Software.
|
||
|
|
#
|
||
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
|
||
|
|
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
||
|
|
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||
|
|
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||
|
|
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||
|
|
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||
|
|
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||
|
|
|
||
|
|
__revision__ = "src/engine/SCons/Subst.py 5134 2010/08/16 23:02:40 bdeegan"
|
||
|
|
|
||
|
|
import collections
|
||
|
|
import re
|
||
|
|
|
||
|
|
import SCons.Errors
|
||
|
|
|
||
|
|
from SCons.Util import is_String, is_Sequence
|
||
|
|
|
||
|
|
# Indexed by the SUBST_* constants below.
|
||
|
|
_strconv = [SCons.Util.to_String_for_subst,
|
||
|
|
SCons.Util.to_String_for_subst,
|
||
|
|
SCons.Util.to_String_for_signature]
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
AllowableExceptions = (IndexError, NameError)
|
||
|
|
|
||
|
|
def SetAllowableExceptions(*excepts):
|
||
|
|
global AllowableExceptions
|
||
|
|
AllowableExceptions = [_f for _f in excepts if _f]
|
||
|
|
|
||
|
|
def raise_exception(exception, target, s):
|
||
|
|
name = exception.__class__.__name__
|
||
|
|
msg = "%s `%s' trying to evaluate `%s'" % (name, exception, s)
|
||
|
|
if target:
|
||
|
|
raise SCons.Errors.BuildError(target[0], msg)
|
||
|
|
else:
|
||
|
|
raise SCons.Errors.UserError(msg)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
class Literal(object):
|
||
|
|
"""A wrapper for a string. If you use this object wrapped
|
||
|
|
around a string, then it will be interpreted as literal.
|
||
|
|
When passed to the command interpreter, all special
|
||
|
|
characters will be escaped."""
|
||
|
|
def __init__(self, lstr):
|
||
|
|
self.lstr = lstr
|
||
|
|
|
||
|
|
def __str__(self):
|
||
|
|
return self.lstr
|
||
|
|
|
||
|
|
def escape(self, escape_func):
|
||
|
|
return escape_func(self.lstr)
|
||
|
|
|
||
|
|
def for_signature(self):
|
||
|
|
return self.lstr
|
||
|
|
|
||
|
|
def is_literal(self):
|
||
|
|
return 1
|
||
|
|
|
||
|
|
class SpecialAttrWrapper(object):
|
||
|
|
"""This is a wrapper for what we call a 'Node special attribute.'
|
||
|
|
This is any of the attributes of a Node that we can reference from
|
||
|
|
Environment variable substitution, such as $TARGET.abspath or
|
||
|
|
$SOURCES[1].filebase. We implement the same methods as Literal
|
||
|
|
so we can handle special characters, plus a for_signature method,
|
||
|
|
such that we can return some canonical string during signature
|
||
|
|
calculation to avoid unnecessary rebuilds."""
|
||
|
|
|
||
|
|
def __init__(self, lstr, for_signature=None):
|
||
|
|
"""The for_signature parameter, if supplied, will be the
|
||
|
|
canonical string we return from for_signature(). Else
|
||
|
|
we will simply return lstr."""
|
||
|
|
self.lstr = lstr
|
||
|
|
if for_signature:
|
||
|
|
self.forsig = for_signature
|
||
|
|
else:
|
||
|
|
self.forsig = lstr
|
||
|
|
|
||
|
|
def __str__(self):
|
||
|
|
return self.lstr
|
||
|
|
|
||
|
|
def escape(self, escape_func):
|
||
|
|
return escape_func(self.lstr)
|
||
|
|
|
||
|
|
def for_signature(self):
|
||
|
|
return self.forsig
|
||
|
|
|
||
|
|
def is_literal(self):
|
||
|
|
return 1
|
||
|
|
|
||
|
|
def quote_spaces(arg):
|
||
|
|
"""Generic function for putting double quotes around any string that
|
||
|
|
has white space in it."""
|
||
|
|
if ' ' in arg or '\t' in arg:
|
||
|
|
return '"%s"' % arg
|
||
|
|
else:
|
||
|
|
return str(arg)
|
||
|
|
|
||
|
|
class CmdStringHolder(collections.UserString):
|
||
|
|
"""This is a special class used to hold strings generated by
|
||
|
|
scons_subst() and scons_subst_list(). It defines a special method
|
||
|
|
escape(). When passed a function with an escape algorithm for a
|
||
|
|
particular platform, it will return the contained string with the
|
||
|
|
proper escape sequences inserted.
|
||
|
|
"""
|
||
|
|
def __init__(self, cmd, literal=None):
|
||
|
|
collections.UserString.__init__(self, cmd)
|
||
|
|
self.literal = literal
|
||
|
|
|
||
|
|
def is_literal(self):
|
||
|
|
return self.literal
|
||
|
|
|
||
|
|
def escape(self, escape_func, quote_func=quote_spaces):
|
||
|
|
"""Escape the string with the supplied function. The
|
||
|
|
function is expected to take an arbitrary string, then
|
||
|
|
return it with all special characters escaped and ready
|
||
|
|
for passing to the command interpreter.
|
||
|
|
|
||
|
|
After calling this function, the next call to str() will
|
||
|
|
return the escaped string.
|
||
|
|
"""
|
||
|
|
|
||
|
|
if self.is_literal():
|
||
|
|
return escape_func(self.data)
|
||
|
|
elif ' ' in self.data or '\t' in self.data:
|
||
|
|
return quote_func(self.data)
|
||
|
|
else:
|
||
|
|
return self.data
|
||
|
|
|
||
|
|
def escape_list(mylist, escape_func):
|
||
|
|
"""Escape a list of arguments by running the specified escape_func
|
||
|
|
on every object in the list that has an escape() method."""
|
||
|
|
def escape(obj, escape_func=escape_func):
|
||
|
|
try:
|
||
|
|
e = obj.escape
|
||
|
|
except AttributeError:
|
||
|
|
return obj
|
||
|
|
else:
|
||
|
|
return e(escape_func)
|
||
|
|
return list(map(escape, mylist))
|
||
|
|
|
||
|
|
class NLWrapper(object):
|
||
|
|
"""A wrapper class that delays turning a list of sources or targets
|
||
|
|
into a NodeList until it's needed. The specified function supplied
|
||
|
|
when the object is initialized is responsible for turning raw nodes
|
||
|
|
into proxies that implement the special attributes like .abspath,
|
||
|
|
.source, etc. This way, we avoid creating those proxies just
|
||
|
|
"in case" someone is going to use $TARGET or the like, and only
|
||
|
|
go through the trouble if we really have to.
|
||
|
|
|
||
|
|
In practice, this might be a wash performance-wise, but it's a little
|
||
|
|
cleaner conceptually...
|
||
|
|
"""
|
||
|
|
|
||
|
|
def __init__(self, list, func):
|
||
|
|
self.list = list
|
||
|
|
self.func = func
|
||
|
|
def _return_nodelist(self):
|
||
|
|
return self.nodelist
|
||
|
|
def _gen_nodelist(self):
|
||
|
|
mylist = self.list
|
||
|
|
if mylist is None:
|
||
|
|
mylist = []
|
||
|
|
elif not is_Sequence(mylist):
|
||
|
|
mylist = [mylist]
|
||
|
|
# The map(self.func) call is what actually turns
|
||
|
|
# a list into appropriate proxies.
|
||
|
|
self.nodelist = SCons.Util.NodeList(list(map(self.func, mylist)))
|
||
|
|
self._create_nodelist = self._return_nodelist
|
||
|
|
return self.nodelist
|
||
|
|
_create_nodelist = _gen_nodelist
|
||
|
|
|
||
|
|
|
||
|
|
class Targets_or_Sources(collections.UserList):
|
||
|
|
"""A class that implements $TARGETS or $SOURCES expansions by in turn
|
||
|
|
wrapping a NLWrapper. This class handles the different methods used
|
||
|
|
to access the list, calling the NLWrapper to create proxies on demand.
|
||
|
|
|
||
|
|
Note that we subclass collections.UserList purely so that the
|
||
|
|
is_Sequence() function will identify an object of this class as
|
||
|
|
a list during variable expansion. We're not really using any
|
||
|
|
collections.UserList methods in practice.
|
||
|
|
"""
|
||
|
|
def __init__(self, nl):
|
||
|
|
self.nl = nl
|
||
|
|
def __getattr__(self, attr):
|
||
|
|
nl = self.nl._create_nodelist()
|
||
|
|
return getattr(nl, attr)
|
||
|
|
def __getitem__(self, i):
|
||
|
|
nl = self.nl._create_nodelist()
|
||
|
|
return nl[i]
|
||
|
|
def __getslice__(self, i, j):
|
||
|
|
nl = self.nl._create_nodelist()
|
||
|
|
i = max(i, 0); j = max(j, 0)
|
||
|
|
return nl[i:j]
|
||
|
|
def __str__(self):
|
||
|
|
nl = self.nl._create_nodelist()
|
||
|
|
return str(nl)
|
||
|
|
def __repr__(self):
|
||
|
|
nl = self.nl._create_nodelist()
|
||
|
|
return repr(nl)
|
||
|
|
|
||
|
|
class Target_or_Source(object):
|
||
|
|
"""A class that implements $TARGET or $SOURCE expansions by in turn
|
||
|
|
wrapping a NLWrapper. This class handles the different methods used
|
||
|
|
to access an individual proxy Node, calling the NLWrapper to create
|
||
|
|
a proxy on demand.
|
||
|
|
"""
|
||
|
|
def __init__(self, nl):
|
||
|
|
self.nl = nl
|
||
|
|
def __getattr__(self, attr):
|
||
|
|
nl = self.nl._create_nodelist()
|
||
|
|
try:
|
||
|
|
nl0 = nl[0]
|
||
|
|
except IndexError:
|
||
|
|
# If there is nothing in the list, then we have no attributes to
|
||
|
|
# pass through, so raise AttributeError for everything.
|
||
|
|
raise AttributeError("NodeList has no attribute: %s" % attr)
|
||
|
|
return getattr(nl0, attr)
|
||
|
|
def __str__(self):
|
||
|
|
nl = self.nl._create_nodelist()
|
||
|
|
if nl:
|
||
|
|
return str(nl[0])
|
||
|
|
return ''
|
||
|
|
def __repr__(self):
|
||
|
|
nl = self.nl._create_nodelist()
|
||
|
|
if nl:
|
||
|
|
return repr(nl[0])
|
||
|
|
return ''
|
||
|
|
|
||
|
|
class NullNodeList(SCons.Util.NullSeq):
|
||
|
|
def __call__(self, *args, **kwargs): return ''
|
||
|
|
def __str__(self): return ''
|
||
|
|
|
||
|
|
NullNodesList = NullNodeList()
|
||
|
|
|
||
|
|
def subst_dict(target, source):
|
||
|
|
"""Create a dictionary for substitution of special
|
||
|
|
construction variables.
|
||
|
|
|
||
|
|
This translates the following special arguments:
|
||
|
|
|
||
|
|
target - the target (object or array of objects),
|
||
|
|
used to generate the TARGET and TARGETS
|
||
|
|
construction variables
|
||
|
|
|
||
|
|
source - the source (object or array of objects),
|
||
|
|
used to generate the SOURCES and SOURCE
|
||
|
|
construction variables
|
||
|
|
"""
|
||
|
|
dict = {}
|
||
|
|
|
||
|
|
if target:
|
||
|
|
def get_tgt_subst_proxy(thing):
|
||
|
|
try:
|
||
|
|
subst_proxy = thing.get_subst_proxy()
|
||
|
|
except AttributeError:
|
||
|
|
subst_proxy = thing # probably a string, just return it
|
||
|
|
return subst_proxy
|
||
|
|
tnl = NLWrapper(target, get_tgt_subst_proxy)
|
||
|
|
dict['TARGETS'] = Targets_or_Sources(tnl)
|
||
|
|
dict['TARGET'] = Target_or_Source(tnl)
|
||
|
|
|
||
|
|
# This is a total cheat, but hopefully this dictionary goes
|
||
|
|
# away soon anyway. We just let these expand to $TARGETS
|
||
|
|
# because that's "good enough" for the use of ToolSurrogates
|
||
|
|
# (see test/ToolSurrogate.py) to generate documentation.
|
||
|
|
dict['CHANGED_TARGETS'] = '$TARGETS'
|
||
|
|
dict['UNCHANGED_TARGETS'] = '$TARGETS'
|
||
|
|
else:
|
||
|
|
dict['TARGETS'] = NullNodesList
|
||
|
|
dict['TARGET'] = NullNodesList
|
||
|
|
|
||
|
|
if source:
|
||
|
|
def get_src_subst_proxy(node):
|
||
|
|
try:
|
||
|
|
rfile = node.rfile
|
||
|
|
except AttributeError:
|
||
|
|
pass
|
||
|
|
else:
|
||
|
|
node = rfile()
|
||
|
|
try:
|
||
|
|
return node.get_subst_proxy()
|
||
|
|
except AttributeError:
|
||
|
|
return node # probably a String, just return it
|
||
|
|
snl = NLWrapper(source, get_src_subst_proxy)
|
||
|
|
dict['SOURCES'] = Targets_or_Sources(snl)
|
||
|
|
dict['SOURCE'] = Target_or_Source(snl)
|
||
|
|
|
||
|
|
# This is a total cheat, but hopefully this dictionary goes
|
||
|
|
# away soon anyway. We just let these expand to $TARGETS
|
||
|
|
# because that's "good enough" for the use of ToolSurrogates
|
||
|
|
# (see test/ToolSurrogate.py) to generate documentation.
|
||
|
|
dict['CHANGED_SOURCES'] = '$SOURCES'
|
||
|
|
dict['UNCHANGED_SOURCES'] = '$SOURCES'
|
||
|
|
else:
|
||
|
|
dict['SOURCES'] = NullNodesList
|
||
|
|
dict['SOURCE'] = NullNodesList
|
||
|
|
|
||
|
|
return dict
|
||
|
|
|
||
|
|
# Constants for the "mode" parameter to scons_subst_list() and
|
||
|
|
# scons_subst(). SUBST_RAW gives the raw command line. SUBST_CMD
|
||
|
|
# gives a command line suitable for passing to a shell. SUBST_SIG
|
||
|
|
# gives a command line appropriate for calculating the signature
|
||
|
|
# of a command line...if this changes, we should rebuild.
|
||
|
|
SUBST_CMD = 0
|
||
|
|
SUBST_RAW = 1
|
||
|
|
SUBST_SIG = 2
|
||
|
|
|
||
|
|
_rm = re.compile(r'\$[()]')
|
||
|
|
_remove = re.compile(r'\$\([^\$]*(\$[^\)][^\$]*)*\$\)')
|
||
|
|
|
||
|
|
# Indexed by the SUBST_* constants above.
|
||
|
|
_regex_remove = [ _rm, None, _remove ]
|
||
|
|
|
||
|
|
def _rm_list(list):
|
||
|
|
#return [ l for l in list if not l in ('$(', '$)') ]
|
||
|
|
return [l for l in list if not l in ('$(', '$)')]
|
||
|
|
|
||
|
|
def _remove_list(list):
|
||
|
|
result = []
|
||
|
|
do_append = result.append
|
||
|
|
for l in list:
|
||
|
|
if l == '$(':
|
||
|
|
do_append = lambda x: None
|
||
|
|
elif l == '$)':
|
||
|
|
do_append = result.append
|
||
|
|
else:
|
||
|
|
do_append(l)
|
||
|
|
return result
|
||
|
|
|
||
|
|
# Indexed by the SUBST_* constants above.
|
||
|
|
_list_remove = [ _rm_list, None, _remove_list ]
|
||
|
|
|
||
|
|
# Regular expressions for splitting strings and handling substitutions,
|
||
|
|
# for use by the scons_subst() and scons_subst_list() functions:
|
||
|
|
#
|
||
|
|
# The first expression compiled matches all of the $-introduced tokens
|
||
|
|
# that we need to process in some way, and is used for substitutions.
|
||
|
|
# The expressions it matches are:
|
||
|
|
#
|
||
|
|
# "$$"
|
||
|
|
# "$("
|
||
|
|
# "$)"
|
||
|
|
# "$variable" [must begin with alphabetic or underscore]
|
||
|
|
# "${any stuff}"
|
||
|
|
#
|
||
|
|
# The second expression compiled is used for splitting strings into tokens
|
||
|
|
# to be processed, and it matches all of the tokens listed above, plus
|
||
|
|
# the following that affect how arguments do or don't get joined together:
|
||
|
|
#
|
||
|
|
# " " [white space]
|
||
|
|
# "non-white-space" [without any dollar signs]
|
||
|
|
# "$" [single dollar sign]
|
||
|
|
#
|
||
|
|
_dollar_exps_str = r'\$[\$\(\)]|\$[_a-zA-Z][\.\w]*|\${[^}]*}'
|
||
|
|
_dollar_exps = re.compile(r'(%s)' % _dollar_exps_str)
|
||
|
|
_separate_args = re.compile(r'(%s|\s+|[^\s\$]+|\$)' % _dollar_exps_str)
|
||
|
|
|
||
|
|
# This regular expression is used to replace strings of multiple white
|
||
|
|
# space characters in the string result from the scons_subst() function.
|
||
|
|
_space_sep = re.compile(r'[\t ]+(?![^{]*})')
|
||
|
|
|
||
|
|
def scons_subst(strSubst, env, mode=SUBST_RAW, target=None, source=None, gvars={}, lvars={}, conv=None):
|
||
|
|
"""Expand a string or list containing construction variable
|
||
|
|
substitutions.
|
||
|
|
|
||
|
|
This is the work-horse function for substitutions in file names
|
||
|
|
and the like. The companion scons_subst_list() function (below)
|
||
|
|
handles separating command lines into lists of arguments, so see
|
||
|
|
that function if that's what you're looking for.
|
||
|
|
"""
|
||
|
|
if isinstance(strSubst, str) and strSubst.find('$') < 0:
|
||
|
|
return strSubst
|
||
|
|
|
||
|
|
class StringSubber(object):
|
||
|
|
"""A class to construct the results of a scons_subst() call.
|
||
|
|
|
||
|
|
This binds a specific construction environment, mode, target and
|
||
|
|
source with two methods (substitute() and expand()) that handle
|
||
|
|
the expansion.
|
||
|
|
"""
|
||
|
|
def __init__(self, env, mode, conv, gvars):
|
||
|
|
self.env = env
|
||
|
|
self.mode = mode
|
||
|
|
self.conv = conv
|
||
|
|
self.gvars = gvars
|
||
|
|
|
||
|
|
def expand(self, s, lvars):
|
||
|
|
"""Expand a single "token" as necessary, returning an
|
||
|
|
appropriate string containing the expansion.
|
||
|
|
|
||
|
|
This handles expanding different types of things (strings,
|
||
|
|
lists, callables) appropriately. It calls the wrapper
|
||
|
|
substitute() method to re-expand things as necessary, so that
|
||
|
|
the results of expansions of side-by-side strings still get
|
||
|
|
re-evaluated separately, not smushed together.
|
||
|
|
"""
|
||
|
|
if is_String(s):
|
||
|
|
try:
|
||
|
|
s0, s1 = s[:2]
|
||
|
|
except (IndexError, ValueError):
|
||
|
|
return s
|
||
|
|
if s0 != '$':
|
||
|
|
return s
|
||
|
|
if s1 == '$':
|
||
|
|
return '$'
|
||
|
|
elif s1 in '()':
|
||
|
|
return s
|
||
|
|
else:
|
||
|
|
key = s[1:]
|
||
|
|
if key[0] == '{' or key.find('.') >= 0:
|
||
|
|
if key[0] == '{':
|
||
|
|
key = key[1:-1]
|
||
|
|
try:
|
||
|
|
s = eval(key, self.gvars, lvars)
|
||
|
|
except KeyboardInterrupt:
|
||
|
|
raise
|
||
|
|
except Exception, e:
|
||
|
|
if e.__class__ in AllowableExceptions:
|
||
|
|
return ''
|
||
|
|
raise_exception(e, lvars['TARGETS'], s)
|
||
|
|
else:
|
||
|
|
if key in lvars:
|
||
|
|
s = lvars[key]
|
||
|
|
elif key in self.gvars:
|
||
|
|
s = self.gvars[key]
|
||
|
|
elif not NameError in AllowableExceptions:
|
||
|
|
raise_exception(NameError(key), lvars['TARGETS'], s)
|
||
|
|
else:
|
||
|
|
return ''
|
||
|
|
|
||
|
|
# Before re-expanding the result, handle
|
||
|
|
# recursive expansion by copying the local
|
||
|
|
# variable dictionary and overwriting a null
|
||
|
|
# string for the value of the variable name
|
||
|
|
# we just expanded.
|
||
|
|
#
|
||
|
|
# This could potentially be optimized by only
|
||
|
|
# copying lvars when s contains more expansions,
|
||
|
|
# but lvars is usually supposed to be pretty
|
||
|
|
# small, and deeply nested variable expansions
|
||
|
|
# are probably more the exception than the norm,
|
||
|
|
# so it should be tolerable for now.
|
||
|
|
lv = lvars.copy()
|
||
|
|
var = key.split('.')[0]
|
||
|
|
lv[var] = ''
|
||
|
|
return self.substitute(s, lv)
|
||
|
|
elif is_Sequence(s):
|
||
|
|
def func(l, conv=self.conv, substitute=self.substitute, lvars=lvars):
|
||
|
|
return conv(substitute(l, lvars))
|
||
|
|
return list(map(func, s))
|
||
|
|
elif callable(s):
|
||
|
|
try:
|
||
|
|
s = s(target=lvars['TARGETS'],
|
||
|
|
source=lvars['SOURCES'],
|
||
|
|
env=self.env,
|
||
|
|
for_signature=(self.mode != SUBST_CMD))
|
||
|
|
except TypeError:
|
||
|
|
# This probably indicates that it's a callable
|
||
|
|
# object that doesn't match our calling arguments
|
||
|
|
# (like an Action).
|
||
|
|
if self.mode == SUBST_RAW:
|
||
|
|
return s
|
||
|
|
s = self.conv(s)
|
||
|
|
return self.substitute(s, lvars)
|
||
|
|
elif s is None:
|
||
|
|
return ''
|
||
|
|
else:
|
||
|
|
return s
|
||
|
|
|
||
|
|
def substitute(self, args, lvars):
|
||
|
|
"""Substitute expansions in an argument or list of arguments.
|
||
|
|
|
||
|
|
This serves as a wrapper for splitting up a string into
|
||
|
|
separate tokens.
|
||
|
|
"""
|
||
|
|
if is_String(args) and not isinstance(args, CmdStringHolder):
|
||
|
|
args = str(args) # In case it's a UserString.
|
||
|
|
try:
|
||
|
|
def sub_match(match):
|
||
|
|
return self.conv(self.expand(match.group(1), lvars))
|
||
|
|
result = _dollar_exps.sub(sub_match, args)
|
||
|
|
except TypeError:
|
||
|
|
# If the internal conversion routine doesn't return
|
||
|
|
# strings (it could be overridden to return Nodes, for
|
||
|
|
# example), then the 1.5.2 re module will throw this
|
||
|
|
# exception. Back off to a slower, general-purpose
|
||
|
|
# algorithm that works for all data types.
|
||
|
|
args = _separate_args.findall(args)
|
||
|
|
result = []
|
||
|
|
for a in args:
|
||
|
|
result.append(self.conv(self.expand(a, lvars)))
|
||
|
|
if len(result) == 1:
|
||
|
|
result = result[0]
|
||
|
|
else:
|
||
|
|
result = ''.join(map(str, result))
|
||
|
|
return result
|
||
|
|
else:
|
||
|
|
return self.expand(args, lvars)
|
||
|
|
|
||
|
|
if conv is None:
|
||
|
|
conv = _strconv[mode]
|
||
|
|
|
||
|
|
# Doing this every time is a bit of a waste, since the Executor
|
||
|
|
# has typically already populated the OverrideEnvironment with
|
||
|
|
# $TARGET/$SOURCE variables. We're keeping this (for now), though,
|
||
|
|
# because it supports existing behavior that allows us to call
|
||
|
|
# an Action directly with an arbitrary target+source pair, which
|
||
|
|
# we use in Tool/tex.py to handle calling $BIBTEX when necessary.
|
||
|
|
# If we dropped that behavior (or found another way to cover it),
|
||
|
|
# we could get rid of this call completely and just rely on the
|
||
|
|
# Executor setting the variables.
|
||
|
|
if 'TARGET' not in lvars:
|
||
|
|
d = subst_dict(target, source)
|
||
|
|
if d:
|
||
|
|
lvars = lvars.copy()
|
||
|
|
lvars.update(d)
|
||
|
|
|
||
|
|
# We're (most likely) going to eval() things. If Python doesn't
|
||
|
|
# find a __builtins__ value in the global dictionary used for eval(),
|
||
|
|
# it copies the current global values for you. Avoid this by
|
||
|
|
# setting it explicitly and then deleting, so we don't pollute the
|
||
|
|
# construction environment Dictionary(ies) that are typically used
|
||
|
|
# for expansion.
|
||
|
|
gvars['__builtins__'] = __builtins__
|
||
|
|
|
||
|
|
ss = StringSubber(env, mode, conv, gvars)
|
||
|
|
result = ss.substitute(strSubst, lvars)
|
||
|
|
|
||
|
|
try:
|
||
|
|
del gvars['__builtins__']
|
||
|
|
except KeyError:
|
||
|
|
pass
|
||
|
|
|
||
|
|
if is_String(result):
|
||
|
|
# Remove $(-$) pairs and any stuff in between,
|
||
|
|
# if that's appropriate.
|
||
|
|
remove = _regex_remove[mode]
|
||
|
|
if remove:
|
||
|
|
result = remove.sub('', result)
|
||
|
|
if mode != SUBST_RAW:
|
||
|
|
# Compress strings of white space characters into
|
||
|
|
# a single space.
|
||
|
|
result = _space_sep.sub(' ', result).strip()
|
||
|
|
elif is_Sequence(result):
|
||
|
|
remove = _list_remove[mode]
|
||
|
|
if remove:
|
||
|
|
result = remove(result)
|
||
|
|
|
||
|
|
return result
|
||
|
|
|
||
|
|
#Subst_List_Strings = {}
|
||
|
|
|
||
|
|
def scons_subst_list(strSubst, env, mode=SUBST_RAW, target=None, source=None, gvars={}, lvars={}, conv=None):
|
||
|
|
"""Substitute construction variables in a string (or list or other
|
||
|
|
object) and separate the arguments into a command list.
|
||
|
|
|
||
|
|
The companion scons_subst() function (above) handles basic
|
||
|
|
substitutions within strings, so see that function instead
|
||
|
|
if that's what you're looking for.
|
||
|
|
"""
|
||
|
|
# try:
|
||
|
|
# Subst_List_Strings[strSubst] = Subst_List_Strings[strSubst] + 1
|
||
|
|
# except KeyError:
|
||
|
|
# Subst_List_Strings[strSubst] = 1
|
||
|
|
# import SCons.Debug
|
||
|
|
# SCons.Debug.caller_trace(1)
|
||
|
|
class ListSubber(collections.UserList):
|
||
|
|
"""A class to construct the results of a scons_subst_list() call.
|
||
|
|
|
||
|
|
Like StringSubber, this class binds a specific construction
|
||
|
|
environment, mode, target and source with two methods
|
||
|
|
(substitute() and expand()) that handle the expansion.
|
||
|
|
|
||
|
|
In addition, however, this class is used to track the state of
|
||
|
|
the result(s) we're gathering so we can do the appropriate thing
|
||
|
|
whenever we have to append another word to the result--start a new
|
||
|
|
line, start a new word, append to the current word, etc. We do
|
||
|
|
this by setting the "append" attribute to the right method so
|
||
|
|
that our wrapper methods only need ever call ListSubber.append(),
|
||
|
|
and the rest of the object takes care of doing the right thing
|
||
|
|
internally.
|
||
|
|
"""
|
||
|
|
def __init__(self, env, mode, conv, gvars):
|
||
|
|
collections.UserList.__init__(self, [])
|
||
|
|
self.env = env
|
||
|
|
self.mode = mode
|
||
|
|
self.conv = conv
|
||
|
|
self.gvars = gvars
|
||
|
|
|
||
|
|
if self.mode == SUBST_RAW:
|
||
|
|
self.add_strip = lambda x: self.append(x)
|
||
|
|
else:
|
||
|
|
self.add_strip = lambda x: None
|
||
|
|
self.in_strip = None
|
||
|
|
self.next_line()
|
||
|
|
|
||
|
|
def expand(self, s, lvars, within_list):
|
||
|
|
"""Expand a single "token" as necessary, appending the
|
||
|
|
expansion to the current result.
|
||
|
|
|
||
|
|
This handles expanding different types of things (strings,
|
||
|
|
lists, callables) appropriately. It calls the wrapper
|
||
|
|
substitute() method to re-expand things as necessary, so that
|
||
|
|
the results of expansions of side-by-side strings still get
|
||
|
|
re-evaluated separately, not smushed together.
|
||
|
|
"""
|
||
|
|
|
||
|
|
if is_String(s):
|
||
|
|
try:
|
||
|
|
s0, s1 = s[:2]
|
||
|
|
except (IndexError, ValueError):
|
||
|
|
self.append(s)
|
||
|
|
return
|
||
|
|
if s0 != '$':
|
||
|
|
self.append(s)
|
||
|
|
return
|
||
|
|
if s1 == '$':
|
||
|
|
self.append('$')
|
||
|
|
elif s1 == '(':
|
||
|
|
self.open_strip('$(')
|
||
|
|
elif s1 == ')':
|
||
|
|
self.close_strip('$)')
|
||
|
|
else:
|
||
|
|
key = s[1:]
|
||
|
|
if key[0] == '{' or key.find('.') >= 0:
|
||
|
|
if key[0] == '{':
|
||
|
|
key = key[1:-1]
|
||
|
|
try:
|
||
|
|
s = eval(key, self.gvars, lvars)
|
||
|
|
except KeyboardInterrupt:
|
||
|
|
raise
|
||
|
|
except Exception, e:
|
||
|
|
if e.__class__ in AllowableExceptions:
|
||
|
|
return
|
||
|
|
raise_exception(e, lvars['TARGETS'], s)
|
||
|
|
else:
|
||
|
|
if key in lvars:
|
||
|
|
s = lvars[key]
|
||
|
|
elif key in self.gvars:
|
||
|
|
s = self.gvars[key]
|
||
|
|
elif not NameError in AllowableExceptions:
|
||
|
|
raise_exception(NameError(), lvars['TARGETS'], s)
|
||
|
|
else:
|
||
|
|
return
|
||
|
|
|
||
|
|
# Before re-expanding the result, handle
|
||
|
|
# recursive expansion by copying the local
|
||
|
|
# variable dictionary and overwriting a null
|
||
|
|
# string for the value of the variable name
|
||
|
|
# we just expanded.
|
||
|
|
lv = lvars.copy()
|
||
|
|
var = key.split('.')[0]
|
||
|
|
lv[var] = ''
|
||
|
|
self.substitute(s, lv, 0)
|
||
|
|
self.this_word()
|
||
|
|
elif is_Sequence(s):
|
||
|
|
for a in s:
|
||
|
|
self.substitute(a, lvars, 1)
|
||
|
|
self.next_word()
|
||
|
|
elif callable(s):
|
||
|
|
try:
|
||
|
|
s = s(target=lvars['TARGETS'],
|
||
|
|
source=lvars['SOURCES'],
|
||
|
|
env=self.env,
|
||
|
|
for_signature=(self.mode != SUBST_CMD))
|
||
|
|
except TypeError:
|
||
|
|
# This probably indicates that it's a callable
|
||
|
|
# object that doesn't match our calling arguments
|
||
|
|
# (like an Action).
|
||
|
|
if self.mode == SUBST_RAW:
|
||
|
|
self.append(s)
|
||
|
|
return
|
||
|
|
s = self.conv(s)
|
||
|
|
self.substitute(s, lvars, within_list)
|
||
|
|
elif s is None:
|
||
|
|
self.this_word()
|
||
|
|
else:
|
||
|
|
self.append(s)
|
||
|
|
|
||
|
|
def substitute(self, args, lvars, within_list):
|
||
|
|
"""Substitute expansions in an argument or list of arguments.
|
||
|
|
|
||
|
|
This serves as a wrapper for splitting up a string into
|
||
|
|
separate tokens.
|
||
|
|
"""
|
||
|
|
|
||
|
|
if is_String(args) and not isinstance(args, CmdStringHolder):
|
||
|
|
args = str(args) # In case it's a UserString.
|
||
|
|
args = _separate_args.findall(args)
|
||
|
|
for a in args:
|
||
|
|
if a[0] in ' \t\n\r\f\v':
|
||
|
|
if '\n' in a:
|
||
|
|
self.next_line()
|
||
|
|
elif within_list:
|
||
|
|
self.append(a)
|
||
|
|
else:
|
||
|
|
self.next_word()
|
||
|
|
else:
|
||
|
|
self.expand(a, lvars, within_list)
|
||
|
|
else:
|
||
|
|
self.expand(args, lvars, within_list)
|
||
|
|
|
||
|
|
def next_line(self):
|
||
|
|
"""Arrange for the next word to start a new line. This
|
||
|
|
is like starting a new word, except that we have to append
|
||
|
|
another line to the result."""
|
||
|
|
collections.UserList.append(self, [])
|
||
|
|
self.next_word()
|
||
|
|
|
||
|
|
def this_word(self):
|
||
|
|
"""Arrange for the next word to append to the end of the
|
||
|
|
current last word in the result."""
|
||
|
|
self.append = self.add_to_current_word
|
||
|
|
|
||
|
|
def next_word(self):
|
||
|
|
"""Arrange for the next word to start a new word."""
|
||
|
|
self.append = self.add_new_word
|
||
|
|
|
||
|
|
def add_to_current_word(self, x):
|
||
|
|
"""Append the string x to the end of the current last word
|
||
|
|
in the result. If that is not possible, then just add
|
||
|
|
it as a new word. Make sure the entire concatenated string
|
||
|
|
inherits the object attributes of x (in particular, the
|
||
|
|
escape function) by wrapping it as CmdStringHolder."""
|
||
|
|
|
||
|
|
if not self.in_strip or self.mode != SUBST_SIG:
|
||
|
|
try:
|
||
|
|
current_word = self[-1][-1]
|
||
|
|
except IndexError:
|
||
|
|
self.add_new_word(x)
|
||
|
|
else:
|
||
|
|
# All right, this is a hack and it should probably
|
||
|
|
# be refactored out of existence in the future.
|
||
|
|
# The issue is that we want to smoosh words together
|
||
|
|
# and make one file name that gets escaped if
|
||
|
|
# we're expanding something like foo$EXTENSION,
|
||
|
|
# but we don't want to smoosh them together if
|
||
|
|
# it's something like >$TARGET, because then we'll
|
||
|
|
# treat the '>' like it's part of the file name.
|
||
|
|
# So for now, just hard-code looking for the special
|
||
|
|
# command-line redirection characters...
|
||
|
|
try:
|
||
|
|
last_char = str(current_word)[-1]
|
||
|
|
except IndexError:
|
||
|
|
last_char = '\0'
|
||
|
|
if last_char in '<>|':
|
||
|
|
self.add_new_word(x)
|
||
|
|
else:
|
||
|
|
y = current_word + x
|
||
|
|
|
||
|
|
# We used to treat a word appended to a literal
|
||
|
|
# as a literal itself, but this caused problems
|
||
|
|
# with interpreting quotes around space-separated
|
||
|
|
# targets on command lines. Removing this makes
|
||
|
|
# none of the "substantive" end-to-end tests fail,
|
||
|
|
# so we'll take this out but leave it commented
|
||
|
|
# for now in case there's a problem not covered
|
||
|
|
# by the test cases and we need to resurrect this.
|
||
|
|
#literal1 = self.literal(self[-1][-1])
|
||
|
|
#literal2 = self.literal(x)
|
||
|
|
y = self.conv(y)
|
||
|
|
if is_String(y):
|
||
|
|
#y = CmdStringHolder(y, literal1 or literal2)
|
||
|
|
y = CmdStringHolder(y, None)
|
||
|
|
self[-1][-1] = y
|
||
|
|
|
||
|
|
def add_new_word(self, x):
|
||
|
|
if not self.in_strip or self.mode != SUBST_SIG:
|
||
|
|
literal = self.literal(x)
|
||
|
|
x = self.conv(x)
|
||
|
|
if is_String(x):
|
||
|
|
x = CmdStringHolder(x, literal)
|
||
|
|
self[-1].append(x)
|
||
|
|
self.append = self.add_to_current_word
|
||
|
|
|
||
|
|
def literal(self, x):
|
||
|
|
try:
|
||
|
|
l = x.is_literal
|
||
|
|
except AttributeError:
|
||
|
|
return None
|
||
|
|
else:
|
||
|
|
return l()
|
||
|
|
|
||
|
|
def open_strip(self, x):
|
||
|
|
"""Handle the "open strip" $( token."""
|
||
|
|
self.add_strip(x)
|
||
|
|
self.in_strip = 1
|
||
|
|
|
||
|
|
def close_strip(self, x):
|
||
|
|
"""Handle the "close strip" $) token."""
|
||
|
|
self.add_strip(x)
|
||
|
|
self.in_strip = None
|
||
|
|
|
||
|
|
if conv is None:
|
||
|
|
conv = _strconv[mode]
|
||
|
|
|
||
|
|
# Doing this every time is a bit of a waste, since the Executor
|
||
|
|
# has typically already populated the OverrideEnvironment with
|
||
|
|
# $TARGET/$SOURCE variables. We're keeping this (for now), though,
|
||
|
|
# because it supports existing behavior that allows us to call
|
||
|
|
# an Action directly with an arbitrary target+source pair, which
|
||
|
|
# we use in Tool/tex.py to handle calling $BIBTEX when necessary.
|
||
|
|
# If we dropped that behavior (or found another way to cover it),
|
||
|
|
# we could get rid of this call completely and just rely on the
|
||
|
|
# Executor setting the variables.
|
||
|
|
if 'TARGET' not in lvars:
|
||
|
|
d = subst_dict(target, source)
|
||
|
|
if d:
|
||
|
|
lvars = lvars.copy()
|
||
|
|
lvars.update(d)
|
||
|
|
|
||
|
|
# We're (most likely) going to eval() things. If Python doesn't
|
||
|
|
# find a __builtins__ value in the global dictionary used for eval(),
|
||
|
|
# it copies the current global values for you. Avoid this by
|
||
|
|
# setting it explicitly and then deleting, so we don't pollute the
|
||
|
|
# construction environment Dictionary(ies) that are typically used
|
||
|
|
# for expansion.
|
||
|
|
gvars['__builtins__'] = __builtins__
|
||
|
|
|
||
|
|
ls = ListSubber(env, mode, conv, gvars)
|
||
|
|
ls.substitute(strSubst, lvars, 0)
|
||
|
|
|
||
|
|
try:
|
||
|
|
del gvars['__builtins__']
|
||
|
|
except KeyError:
|
||
|
|
pass
|
||
|
|
|
||
|
|
return ls.data
|
||
|
|
|
||
|
|
def scons_subst_once(strSubst, env, key):
|
||
|
|
"""Perform single (non-recursive) substitution of a single
|
||
|
|
construction variable keyword.
|
||
|
|
|
||
|
|
This is used when setting a variable when copying or overriding values
|
||
|
|
in an Environment. We want to capture (expand) the old value before
|
||
|
|
we override it, so people can do things like:
|
||
|
|
|
||
|
|
env2 = env.Clone(CCFLAGS = '$CCFLAGS -g')
|
||
|
|
|
||
|
|
We do this with some straightforward, brute-force code here...
|
||
|
|
"""
|
||
|
|
if isinstance(strSubst, str) and strSubst.find('$') < 0:
|
||
|
|
return strSubst
|
||
|
|
|
||
|
|
matchlist = ['$' + key, '${' + key + '}']
|
||
|
|
val = env.get(key, '')
|
||
|
|
def sub_match(match, val=val, matchlist=matchlist):
|
||
|
|
a = match.group(1)
|
||
|
|
if a in matchlist:
|
||
|
|
a = val
|
||
|
|
if is_Sequence(a):
|
||
|
|
return ' '.join(map(str, a))
|
||
|
|
else:
|
||
|
|
return str(a)
|
||
|
|
|
||
|
|
if is_Sequence(strSubst):
|
||
|
|
result = []
|
||
|
|
for arg in strSubst:
|
||
|
|
if is_String(arg):
|
||
|
|
if arg in matchlist:
|
||
|
|
arg = val
|
||
|
|
if is_Sequence(arg):
|
||
|
|
result.extend(arg)
|
||
|
|
else:
|
||
|
|
result.append(arg)
|
||
|
|
else:
|
||
|
|
result.append(_dollar_exps.sub(sub_match, arg))
|
||
|
|
else:
|
||
|
|
result.append(arg)
|
||
|
|
return result
|
||
|
|
elif is_String(strSubst):
|
||
|
|
return _dollar_exps.sub(sub_match, strSubst)
|
||
|
|
else:
|
||
|
|
return strSubst
|
||
|
|
|
||
|
|
# Local Variables:
|
||
|
|
# tab-width:4
|
||
|
|
# indent-tabs-mode:nil
|
||
|
|
# End:
|
||
|
|
# vim: set expandtab tabstop=4 shiftwidth=4:
|