This fills in static TARGET, TARGETS, SOURCE and SOURCES
variables so that signatures stay the same every time.
"""
- class lister:
- def __init__(self, fmt):
- self.fmt = fmt
- def _format(self, index):
- # For some reason, I originally made the fake names of
- # the targets and sources 1-based (['__t1__, '__t2__']),
- # not 0-based. We preserve this behavior by adding one
- # to the returned item names, so everyone's targets
- # won't get recompiled if they were using an old
- # version.
- return self.fmt % (index + 1)
- def __str__(self):
- return self._format(0) + " " + self._format(1)
- def __getitem__(self, index):
- return SCons.Util.PathList([self._format(index)])[0]
- def __getslice__(self, i, j):
- slice = []
- for x in range(i, j):
- slice.append(self._format(x))
- return SCons.Util.PathList(slice)
-
dict = {}
for k,v in self.items(): dict[k] = v
- dict['TARGETS'] = lister('__t%d__')
+ dict['TARGETS'] = SCons.Util.Lister('__t%d__')
dict['TARGET'] = dict['TARGETS'][0]
- dict['SOURCES'] = lister('__s%d__')
+ dict['SOURCES'] = SCons.Util.Lister('__s%d__')
dict['SOURCE'] = dict['SOURCES'][0]
return dict
first_part, second_part = split_func(strPath)
list1.append(first_part)
list2.append(second_part)
- return (self.__class__(list1),
- self.__class__(list2))
+ # Note that we return explicit PathList() instances, not
+ # self.__class__(). This makes sure the right attributes are
+ # available even if this object is a Lister, not a PathList.
+ return (PathList(list1), PathList(list2))
def __getBasePath(self):
"""Return the file's directory and file name, with the
def __getAbsPath(self):
"""Return the absolute path"""
- return map(lambda x: updrive(os.path.abspath(x)), self.data)
+ # Note that we return an explicit PathList() instance, not
+ # self.__class__(). This makes sure the right attributes are
+ # available even if this object is a Lister, not a PathList.
+ return PathList(map(lambda x: updrive(os.path.abspath(x)), self.data))
dictSpecialAttrs = { "file" : __getFileName,
"base" : __getBasePath,
def __str__(self):
return string.join(self.data)
+ def to_String(self):
+ # Used by our variable-interpolation to interpolate a string.
+ # The interpolation doesn't use __str__() for this because then
+ # it interpolates other lists as "['x', 'y']".
+ return string.join(self.data)
+
def __repr__(self):
return repr(string.join(self.data))
# suffix and basepath.
return self.__class__([ UserList.UserList.__getitem__(self, item), ])
+class Lister(PathList):
+ """A special breed of fake list that not only supports the inherited
+ "path dissection" attributes of PathList, but also uses a supplied
+ format string to generate arbitrary (slices of) individually-named
+ elements on the fly.
+ """
+ def __init__(self, fmt):
+ self.fmt = fmt
+ PathList.__init__(self, [ self._element(0), self._element(1) ])
+ def __getitem__(self, index):
+ return PathList([self._element(index)])
+ def _element(self, index):
+ """Generate the index'th element in this list."""
+ # For some reason, I originally made the fake names of
+ # the targets and sources 1-based (['__t1__, '__t2__']),
+ # not 0-based. We preserve this behavior by adding one
+ # to the returned item names, so everyone's targets
+ # won't get recompiled if they were using an old version.
+ return self.fmt % (index + 1)
+ def __iter__(self):
+ """Return an iterator object for Python 2.2."""
+ class Lister_iter:
+ def __init__(self, data):
+ self.data = data
+ self.index = 0
+ def __iter__(self):
+ return self
+ def next(self):
+ try:
+ element = self.data[self.index]
+ except IndexError:
+ raise StopIteration
+ self.index = self.index + 1
+ return element
+ return Lister_iter(self.data)
+ def __getslice__(self, i, j):
+ slice = []
+ if j == sys.maxint:
+ j = i + 2
+ for x in range(i, j):
+ slice.append(self._element(x))
+ return PathList(slice)
+
_env_var = re.compile(r'^\$([_a-zA-Z]\w*|{[^}]*})$')
def get_environment_var(varstr):
elif is_String(x):
return _space_sep.sub('\0', x)
elif is_List(x):
- return string.join(map(to_String, x), '\0')
+ try:
+ return x.to_String()
+ except AttributeError:
+ return string.join(map(to_String, x), '\0')
else:
return to_String(x)
if e is None:
s = ''
elif is_List(e):
- s = string.join(map(to_String, e), ' ')
+ try:
+ s = e.to_String()
+ except AttributeError:
+ s = string.join(map(to_String, e), ' ')
else:
s = to_String(e)
except NameError:
class UtilTestCase(unittest.TestCase):
- def test_subst(self):
- """Test the subst function."""
- loc = {}
+ def test_subst_PathList(self):
+ """Test the subst function with PathLists"""
+ loc = {}
loc['TARGETS'] = PathList(map(os.path.normpath, [ "./foo/bar.exe",
"/bar/baz.obj",
"../foo/baz.obj" ]))
newcom = scons_subst("test ${TARGET.dir}", loc, {})
assert newcom == cvt("test foo")
+ cwd = SCons.Util.updrive(os.getcwd())
+
newcom = scons_subst("test ${TARGET.abspath}", loc, {})
- assert newcom == cvt("test %s/foo/bar.exe"%SCons.Util.updrive(os.getcwd())), newcom
+ assert newcom == cvt("test %s/foo/bar.exe" % (cwd)), newcom
newcom = scons_subst("test ${SOURCES.abspath}", loc, {})
- assert newcom == cvt("test %s/foo/blah.cpp %s %s/foo/ack.c"%(SCons.Util.updrive(os.getcwd()),
+ assert newcom == cvt("test %s/foo/blah.cpp %s %s/foo/ack.c"%(cwd,
SCons.Util.updrive(os.path.abspath(os.path.normpath("/bar/ack.cpp"))),
SCons.Util.updrive(os.path.normpath(os.getcwd()+"/..")))), newcom
newcom = scons_subst("test ${SOURCE.abspath}", loc, {})
- assert newcom == cvt("test %s/foo/blah.cpp"%SCons.Util.updrive(os.getcwd())), newcom
+ assert newcom == cvt("test %s/foo/blah.cpp" % (cwd)), newcom
newcom = scons_subst("test $xxx", loc, {})
assert newcom == cvt("test"), newcom
newcom = scons_subst("$$FOO$BAZ", glob, {})
assert newcom == "$FOOBLAT", newcom
+ def test_subst_Lister(self):
+ """Test the subst function with Listers"""
+ loc = {}
+ loc['TARGETS'] = Lister('t%d')
+ loc['TARGET'] = loc['TARGETS'][0]
+ loc['SOURCES'] = Lister('s%d')
+ loc['SOURCE'] = loc['SOURCES'][0]
+ loc['xxx'] = None
+ loc['zero'] = 0
+ loc['one'] = 1
+
+ if os.sep == '/':
+ def cvt(str):
+ return str
+ else:
+ def cvt(str):
+ return string.replace(str, '/', os.sep)
+
+ newcom = scons_subst("test $TARGETS $SOURCES", loc, {})
+ assert newcom == cvt("test t1 t2 s1 s2"), newcom
+
+ newcom = scons_subst("test ${TARGETS[:]} ${SOURCES[0]}", loc, {})
+ assert newcom == cvt("test t1 t2 s1"), newcom
+
+ newcom = scons_subst("test ${TARGETS[1:]}v", loc, {})
+ assert newcom == cvt("test t2 t3v"), newcom
+
+ newcom = scons_subst("test $TARGET", loc, {})
+ assert newcom == cvt("test t1"), newcom
+
+ newcom = scons_subst("test $TARGET$FOO[0]", loc, {})
+ assert newcom == cvt("test t1[0]"), newcom
+
+ newcom = scons_subst("test ${TARGET.file}", loc, {})
+ assert newcom == cvt("test t1"), newcom
+
+ newcom = scons_subst("test ${TARGET.filebase}", loc, {})
+ assert newcom == cvt("test t1"), newcom
+
+ newcom = scons_subst("test ${TARGET.suffix}", loc, {})
+ assert newcom == cvt("test"), newcom
+
+ newcom = scons_subst("test ${TARGET.base}", loc, {})
+ assert newcom == cvt("test t1"), newcom
+
+ newcom = scons_subst("test ${TARGET.dir}", loc, {})
+ assert newcom == cvt("test"), newcom
+
+ cwd = SCons.Util.updrive(os.getcwd())
+
+ newcom = scons_subst("test ${TARGET.abspath}", loc, {})
+ assert newcom == cvt("test %s/t1" % (cwd)), newcom
+
+ newcom = scons_subst("test ${SOURCES.abspath}", loc, {})
+ assert newcom == cvt("test %s/s1 %s/s2" % (cwd, cwd)), newcom
+
+ newcom = scons_subst("test ${SOURCE.abspath}", loc, {})
+ assert newcom == cvt("test %s/s1" % cwd), newcom
+
def test_splitext(self):
assert splitext('foo') == ('foo','')
assert splitext('foo.bar') == ('foo','.bar')
projects / scons.git / commitdiff