- Fix the M4 Builder so that it chdirs to the Repository directory
when the input file is in the source directory of a BuildDir.
+ - Save memory at build time by allowing Nodes to delete their build
+ environments after they've been built.
+
From Vincent Risi:
- Add support for the bcc32, ilink32 and tlib Borland tools.
executor.add_sources(slist)
if executor is None:
executor = SCons.Executor.Executor(builder,
- tlist[0].generate_build_env(env),
+ env,
overrides,
tlist,
slist)
from SCons.Debug import logInstanceCreation
+import SCons.Util
class Executor:
overrides = {}
overrides.update(self.builder.overrides)
overrides.update(self.overrides)
+ try:
+ generate_build_dict = self.targets[0].generate_build_dict
+ except AttributeError:
+ pass
+ else:
+ overrides.update(generate_build_dict())
+ overrides.update(SCons.Util.subst_dict(self.targets, self.sources))
self.build_env = env.Override(overrides)
return self.build_env
for action in action_list:
func(action, self.targets, self.sources, env)
+ def cleanup(self):
+ try:
+ del self.build_env
+ except AttributeError:
+ pass
+
def add_sources(self, sources):
"""Add source files to this Executor's list. This is necessary
for "multi" Builders that can be called repeatedly to build up
't',
['s1', 's2'])
be = x.get_build_env()
- assert be == {'O':'o2', 'X':'xxx'}, be
+ assert be['O'] == 'o2', be['O']
+ assert be['X'] == 'xxx', be['X']
env = MyEnvironment(Y='yyy')
x = SCons.Executor.Executor(MyBuilder(env, {'O':'ob3'}),
't',
's')
be = x.get_build_env()
- assert be == {'O':'oo3', 'Y':'yyy'}, be
+ assert be['O'] == 'oo3', be['O']
+ assert be['Y'] == 'yyy', be['Y']
x = SCons.Executor.Executor(MyBuilder(env, {'O':'ob3'}),
None,
{},
't',
's')
be = x.get_build_env()
- assert be == {'O':'ob3', 'Y':'yyy'}, be
+ assert be['O'] == 'ob3', be['O']
+ assert be['Y'] == 'yyy', be['Y']
def test_get_action_list(self):
"""Test fetching and generating an action list"""
a.append(action)
assert target == ['t1', 't2'], target
assert source == ['s1', 's2'], source
- assert env == {'CALL':'call'}, env
+ assert env['CALL'] == 'call', env['CALL']
x(MyNode(['pre'], ['post']), func)
assert actions == ['pre', 'action1', 'action2', 'post'], actions
+ def test_cleanup(self):
+ """Test cleaning up an Executor"""
+ x = SCons.Executor.Executor('b', 'e', 'o', 't', ['s1', 's2'])
+
+ x.cleanup()
+
+ x.build_env = 'eee'
+ be = x.get_build_env()
+ assert be == 'eee', be
+
+ x.cleanup()
+
+ assert not hasattr(x, 'build_env')
+
def test_add_sources(self):
"""Test adding sources to an Executor"""
x = SCons.Executor.Executor('b', 'e', 'o', 't', ['s1', 's2'])
else:
task.executed()
+ task.postprocess()
+
# Trap import failure so that everything in the Job module but the
# Parallel class (and its dependent classes) will work if the interpreter
task.executed()
else:
task.failed()
+
+ task.postprocess()
self.taskmaster.test_case.failUnless(self.was_prepared,
"the task wasn't prepared")
+ def postprocess(self):
+ self.taskmaster.num_postprocessed = self.taskmaster.num_postprocessed + 1
+
class ExceptionTask:
"""A dummy task class for testing purposes."""
self.taskmaster.test_case.failUnless(self.was_prepared,
"the task wasn't prepared")
+ def postprocess(self):
+ self.taskmaster.num_postprocessed = self.taskmaster.num_postprocessed + 1
+
class Taskmaster:
"""A dummy taskmaster class for testing the job classes."""
self.num_iterated = 0
self.num_executed = 0
self.num_failed = 0
+ self.num_postprocessed = 0
self.Task = Task
# 'guard' guards 'task_begin_list' and 'task_end_list'
try:
def all_tasks_are_iterated(self):
return self.num_iterated == self.num_tasks
+ def all_tasks_are_postprocessed(self):
+ return self.num_postprocessed == self.num_tasks
+
def is_blocked(self):
if self.stop or self.all_tasks_are_executed():
return 0
"all the tests were not executed")
self.failUnless(taskmaster.all_tasks_are_iterated(),
"all the tests were not iterated over")
+ self.failUnless(taskmaster.all_tasks_are_postprocessed(),
+ "all the tests were not postprocessed")
self.failIf(taskmaster.num_failed,
"some task(s) failed to execute")
"all the tests were not executed")
self.failUnless(taskmaster.all_tasks_are_iterated(),
"all the tests were not iterated over")
+ self.failUnless(taskmaster.all_tasks_are_postprocessed(),
+ "all the tests were not postprocessed")
self.failIf(taskmaster.num_failed,
"some task(s) failed to execute")
"all the tests were not executed")
self.failUnless(taskmaster.all_tasks_are_iterated(),
"all the tests were not iterated over")
+ self.failUnless(taskmaster.all_tasks_are_postprocessed(),
+ "all the tests were not postprocessed")
self.failIf(taskmaster.num_failed,
"some task(s) failed to execute")
finally:
"exactly one task should have been iterated")
self.failUnless(taskmaster.num_failed == 1,
"exactly one task should have failed")
+ self.failUnless(taskmaster.num_postprocessed == 1,
+ "exactly one task should have been postprocessed")
class ParallelExceptionTestCase(unittest.TestCase):
def runTest(self):
"one or more task should have been iterated")
self.failUnless(taskmaster.num_failed >= 1,
"one or more tasks should have failed")
+ self.failUnless(taskmaster.num_postprocessed >= 1,
+ "one or more tasks should have been postprocessed")
def suite():
"""Dummy executor class returned by Dir nodes to bamboozle SCons
into thinking we are an actual derived node, where our sources are
our directory entries."""
+ def cleanup(self):
+ pass
def get_raw_contents(self):
return ''
def get_contents(self):
return self.fs.Rsearchall(pathlist, clazz=Dir, must_exist=0,
cwd=self.cwd)
- def generate_build_env(self, env):
- """Generate an appropriate Environment to build this File."""
- return env.Override({'Dir' : self.Dir,
- 'File' : self.File,
- 'RDirs' : self.RDirs})
+ def generate_build_dict(self):
+ """Return an appropriate dictionary of values for building
+ this File."""
+ return {'Dir' : self.Dir,
+ 'File' : self.File,
+ 'RDirs' : self.RDirs}
def _morph(self):
"""Turn a file system node into a File object."""
if b and self.fs.CachePath:
if self.fs.cache_show:
if CacheRetrieveSilent(self, None, None) == 0:
- def do_print(action, targets, sources, env, self=self):
+ def do_print(action, targets, sources, env, s=self):
if action.strfunction:
- al = action.strfunction(targets, self.sources, env)
+ al = action.strfunction(targets, s.sources, env)
if not SCons.Util.is_List(al):
al = [al]
for a in al:
class clearTestCase(unittest.TestCase):
def runTest(self):
+ """Test clearing FS nodes of cached data."""
fs = SCons.Node.FS.FS()
e = fs.Entry('e')
assert not hasattr(f, '_exists')
assert not hasattr(f, '_rexists')
+class postprocessTestCase(unittest.TestCase):
+ def runTest(self):
+ """Test calling the postprocess() method."""
+ fs = SCons.Node.FS.FS()
+
+ e = fs.Entry('e')
+ e.postprocess()
+
+ d = fs.Dir('d')
+ d.postprocess()
+
+ f = fs.File('f')
+ f.postprocess()
+
class SpecialAttrTestCase(unittest.TestCase):
def runTest(self):
"""Test special attributes of file nodes."""
suite.addTest(SConstruct_dirTestCase())
suite.addTest(CacheDirTestCase())
suite.addTest(clearTestCase())
+ suite.addTest(postprocessTestCase())
suite.addTest(SpecialAttrTestCase())
if not unittest.TextTestRunner().run(suite).wasSuccessful():
sys.exit(1)
siginfo = n.get_prevsiginfo()
assert siginfo == (None, None, None), siginfo
+ def test_generate_build_dict(self):
+ """Test the base Node generate_build_dict() method"""
+ n = SCons.Node.Node()
+ dict = n.generate_build_dict()
+ assert dict == {}, dict
+
+ def test_postprocess(self):
+ """Test calling the base Node postprocess() method"""
+ n = SCons.Node.Node()
+ n.postprocess()
+
if __name__ == "__main__":
# what line in what file created the node, for example).
Annotate(self)
- def generate_build_env(self, env):
- """Generate the appropriate Environment to build this node."""
- return env
+ def generate_build_dict(self):
+ """Return an appropriate dictionary of values for building
+ this Node."""
+ return {}
def get_build_env(self):
"""Fetch the appropriate Environment to build this node."""
if not create:
raise
import SCons.Executor
- env = self.generate_build_env(self.builder.env)
executor = SCons.Executor.Executor(self.builder,
- env,
- self.builder.overrides,
+ self.builder.env,
+ {},
[self],
self.sources)
self.executor = executor
so only do thread safe stuff here. Do thread unsafe stuff in
built().
"""
- def do_action(action, targets, sources, env, self=self):
+ def do_action(action, targets, sources, env, s=self):
stat = action(targets, sources, env)
if stat:
- raise SCons.Errors.BuildError(node = self,
+ raise SCons.Errors.BuildError(node = s,
errstr = "Error %d" % stat)
self._for_each_action(do_action)
# node were presumably just changed:
self.del_csig()
+ def postprocess(self):
+ """Clean up anything we don't need to hang onto after we've
+ been built."""
+ try:
+ executor = self.get_executor(create=None)
+ except AttributeError:
+ pass
+ else:
+ executor.cleanup()
+
def clear(self):
"""Completely clear a Node of all its cached state (so that it
can be re-evaluated by interfaces that do continuous integration
return [], None
def depends_on(self, nodes):
return None
+ def postprocess(self):
+ pass
return [MyNode('n1'), MyNode('n2')]
self.scons_env.Append(BUILDERS = {'SConfActionBuilder' : MyBuilder()})
sconf.TryBuild(self.scons_env.SConfActionBuilder)
up to where we exec the SConscript."""
stack = traceback.extract_tb(sys.exc_traceback)
last_text = ""
+ found = 0
i = 0
for frame in stack:
if is_our_exec_statement(last_text):
+ found = 1
break
i = i + 1
last_text = frame[3]
+ if not found:
+ # We did not find our exec statement, so this was actually a bug
+ # in SCons itself. Show the whole stack.
+ i = 0
type = str(sys.exc_type)
if type[:11] == "exceptions.":
type = type[11:]
side_effect.set_state(state)
t.set_state(state)
+ def postprocess(self):
+ """Post process a task after it's been executed."""
+ for t in self.targets:
+ t.postprocess()
+
+
+
def order(dependencies):
"""Re-order a list of dependencies (if we need to)."""
return dependencies
self.side_effect = 0
self.side_effects = []
self.alttargets = []
+ self.postprocessed = None
for kid in kids:
kid.parents.append(self)
def __str__(self):
return self.name
+ def postprocess(self):
+ self.postprocessed = 1
+
class OtherError(Exception):
pass
else:
assert 0, "did not catch expected exception"
+ def test_postprocess(self):
+ """Test postprocessing targets to give them a chance to clean up
+
+ """
+ n1 = Node("n1")
+ tm = SCons.Taskmaster.Taskmaster([n1])
+
+ t = tm.next_task()
+ assert not n1.postprocessed
+ t.postprocess()
+ assert n1.postprocessed
+
+ n2 = Node("n2")
+ n3 = Node("n3")
+ tm = SCons.Taskmaster.Taskmaster([n2, n3])
+
+ assert not n2.postprocessed
+ assert not n3.postprocessed
+ t = tm.next_task()
+ t.postprocess()
+ assert n2.postprocessed
+ assert not n3.postprocessed
+ t = tm.next_task()
+ t.postprocess()
+ assert n2.postprocessed
+ assert n3.postprocessed
+
if __name__ == "__main__":
projects / scons.git / commitdiff