# defined as a SYSTEM entity is, in fact, a file included
# somewhere in the document.
#
-def scansgml(node, env, argument = None):
+def scansgml(node, env, target):
includes = []
contents = node.get_contents()
file, format = m
if format and file[-len(format):] != format:
file = file + format
- if argument and not os.path.isabs(file):
- file = os.path.join(argument, file)
+ if not os.path.isabs(file):
+ a = []
+ f = file
+ while 1:
+ f, tail = os.path.split(f)
+ if tail == 'doc':
+ break
+ a = [tail] + a
+ file = apply(os.path.join, a, {})
includes.append(file)
return includes
+s = Scanner(name = 'sgml', function = scansgml, skeys = ['.sgml', '.mod'])
+env = env.Copy(SCANNERS = [s])
+
if jw:
#
# Always create a version.sgml file containing the version information
'ps' : 1,
'pdf' : 1,
'text' : 0,
- 'scan' : Scanner(name = 'design',
- function = scansgml,
- argument = 'design'),
},
'python10' : {
'htmlindex' : 't1.html',
'pdf' : 0,
'text' : 0,
'graphics' : [ 'arch', 'builder', 'job-task', 'node', 'scanner', 'sig' ],
- 'scan' : Scanner(name = 'python10',
- function = scansgml,
- argument = 'python10'),
},
'user' : {
'htmlindex' : 'book1.html',
- 'html' : 0,
- 'ps' : 0,
- 'pdf' : 0,
+ 'html' : 1,
+ 'ps' : 1,
+ 'pdf' : 1,
'text' : 0,
- 'scan' : Scanner(name = 'user',
- function = scansgml,
- argument = 'user'),
},
}
'copyright.sgml',
]
- s = Scanner(name = 'sgml', function = scansgml)
-
- for sgml in included_sgml:
- File(sgml).scanner_set(s)
-
#
# For each document, build the document itself in HTML, Postscript,
# and PDF formats.
pdf = os.path.join('PDF', 'scons-%s.pdf' % doc)
text = os.path.join('TEXT', 'scons-%s.txt' % doc)
- s = docs[doc].get('scan')
- if s:
- File(main).scanner_set(s)
-
if docs[doc].get('html') and jade:
cmds = [
"rm -f ${TARGET.dir}/*.html",
and return a list of strings (file names)
representing the implicit
dependencies found in the contents.
-The function takes three arguments:
+The function takes three or four arguments:
- def scanner_function(node, env, arg):
+ def scanner_function(node, env, target):
+
+ def scanner_function(node, env, target, arg):
The
.B node
.B env.Dictionary()
method.
+The
+.B target
+argument is the internal
+SCons node representing the target file.
+
The
.B arg
argument is the argument supplied
-when the scanner was created.
+when the scanner was created, if any.
.SH EXAMPLES
include_re = re.compile(r'^include\\s+(\\S+)$', re.M)
-def kfile_scan(node, env, arg):
+def kfile_scan(node, env, target, arg):
contents = node.get_contents()
includes = include_re.findall(contents)
return includes
- Fix so that -c -n does *not* remove the targets!
+ From Anthony Roach:
+
+ - Fix --debug=tree when used with directory targets.
+
+ - Significant internal restructuring of Scanners and Taskmaster.
+
RELEASE 0.06 - Thu, 28 Mar 2002 01:24:29 -0600
-RELEASE 0.06 - Thu, 28 Mar 2002 01:24:29 -0600
+RELEASE 0.07 -
- This is the sixth alpha release of SCons. Please consult the
+ This is the seventh alpha release of SCons. Please consult the
CHANGES.txt file for a list of specific changes since last release.
Please note the following important changes since the previous
release:
- - Python functions as Builder actions now take Node objects, not
+ - Scanner functions now take four arguments.
+
strings, as arguments. The string representation of a Node
object is the file name, so you should change your function
actions to use the str() built-in function to fetch the file
import SCons.Util
-
def Builder(**kw):
"""A factory for builder objects."""
"""Initialize lists of target and source nodes with all of
the proper Builder information.
"""
- src_scanner = None
- if slist:
- src_key = slist[0].scanner_key() # the file suffix
- src_scanner = env.get_scanner(src_key)
- if src_scanner:
- src_scanner = src_scanner.instance(env)
-
+ for s in slist:
+ src_key = slist[0].scanner_key() # the file suffix
+ scanner = env.get_scanner(src_key)
+ if scanner:
+ s.source_scanner = scanner
+
for t in tlist:
- t.cwd = SCons.Node.FS.default_fs.getcwd() # XXX
+ t.cwd = SCons.Node.FS.default_fs.getcwd() # XXX
t.builder_set(builder)
t.env_set(env)
t.add_source(slist)
if builder.scanner:
- t.scanner_set(builder.scanner.instance(env))
- if src_scanner:
- t.src_scanner_set(src_key, src_scanner)
-
-
+ t.target_scanner = builder.scanner
class BuilderBase:
"""Base class for Builders, objects that create output
nodes (files) from input nodes (files).
"""
- def __init__(self, name = None,
- action = None,
- prefix = '',
- suffix = '',
- src_suffix = '',
+ def __init__(self, name = None,
+ action = None,
+ prefix = '',
+ suffix = '',
+ src_suffix = '',
node_factory = SCons.Node.FS.default_fs.File,
target_factory = None,
source_factory = None,
scanner = None):
if name is None:
raise UserError, "You must specify a name for the builder."
- self.name = name
- self.action = SCons.Action.Action(action)
+ self.name = name
+ self.action = SCons.Action.Action(action)
- self.prefix = prefix
- self.suffix = suffix
- self.src_suffix = src_suffix
+ self.prefix = prefix
+ self.suffix = suffix
+ self.src_suffix = src_suffix
self.target_factory = target_factory or node_factory
self.source_factory = source_factory or node_factory
self.scanner = scanner
if self.suffix and self.suffix[0] not in '.$':
- self.suffix = '.' + self.suffix
+ self.suffix = '.' + self.suffix
if self.src_suffix and self.src_suffix[0] not in '.$':
- self.src_suffix = '.' + self.src_suffix
+ self.src_suffix = '.' + self.src_suffix
def __cmp__(self, other):
- return cmp(self.__dict__, other.__dict__)
+ return cmp(self.__dict__, other.__dict__)
def _create_nodes(self, env, target = None, source = None):
"""Create and return lists of target and source nodes.
"""
- def adjustixes(files, pre, suf):
- ret = []
+ def adjustixes(files, pre, suf):
+ ret = []
if SCons.Util.is_String(files):
files = string.split(files)
if not SCons.Util.is_List(files):
- files = [files]
- for f in files:
+ files = [files]
+ for f in files:
if SCons.Util.is_String(f):
- if pre and f[:len(pre)] != pre:
+ if pre and f[:len(pre)] != pre:
path, fn = os.path.split(os.path.normpath(f))
f = os.path.join(path, pre + fn)
- if suf:
- if f[-len(suf):] != suf:
- f = f + suf
- ret.append(f)
- return ret
+ if suf:
+ if f[-len(suf):] != suf:
+ f = f + suf
+ ret.append(f)
+ return ret
tlist = SCons.Node.arg2nodes(adjustixes(target,
env.subst(self.prefix),
def execute(self, **kw):
- """Execute a builder's action to create an output object.
- """
- return apply(self.action.execute, (), kw)
+ """Execute a builder's action to create an output object.
+ """
+ return apply(self.action.execute, (), kw)
def get_raw_contents(self, **kw):
"""Fetch the "contents" of the builder's action.
"""
def __init__(self, src_builder,
name = None,
- action = None,
- prefix = '',
- suffix = '',
- src_suffix = '',
+ action = None,
+ prefix = '',
+ suffix = '',
+ src_suffix = '',
node_factory = SCons.Node.FS.default_fs.File,
target_factory = None,
source_factory = None,
outfile2 = test.workpath('outfile2')
show_string = None
-instanced = None
env_scanner = None
count = 0
class BuilderTestCase(unittest.TestCase):
def test__call__(self):
- """Test calling a builder to establish source dependencies
- """
- class Node:
- def __init__(self, name):
- self.name = name
- self.sources = []
- self.builder = None
- def __str__(self):
- return self.name
- def builder_set(self, builder):
- self.builder = builder
- def env_set(self, env, safe=0):
- self.env = env
- def add_source(self, source):
- self.sources.extend(source)
+ """Test calling a builder to establish source dependencies
+ """
+ class Node:
+ def __init__(self, name):
+ self.name = name
+ self.sources = []
+ self.builder = None
+ def __str__(self):
+ return self.name
+ def builder_set(self, builder):
+ self.builder = builder
+ def env_set(self, env, safe=0):
+ self.env = env
+ def add_source(self, source):
+ self.sources.extend(source)
def scanner_key(self):
return self.name
builder = SCons.Builder.Builder(name="builder", action="foo", node_factory=Node)
- n1 = Node("n1");
- n2 = Node("n2");
- builder(env, target = n1, source = n2)
- assert n1.env == env
- assert n1.builder == builder
- assert n1.sources == [n2]
+ n1 = Node("n1");
+ n2 = Node("n2");
+ builder(env, target = n1, source = n2)
+ assert n1.env == env
+ assert n1.builder == builder
+ assert n1.sources == [n2]
assert not hasattr(n2, 'env')
target = builder(env, target = 'n3', source = 'n4')
assert 0
def test_action(self):
- """Test Builder creation
+ """Test Builder creation
- Verify that we can retrieve the supplied action attribute.
- """
- builder = SCons.Builder.Builder(name="builder", action="foo")
- assert builder.action.command == "foo"
+ Verify that we can retrieve the supplied action attribute.
+ """
+ builder = SCons.Builder.Builder(name="builder", action="foo")
+ assert builder.action.command == "foo"
def test_generator(self):
"""Test Builder creation given a generator function."""
assert builder.action.generator == generator
def test_cmp(self):
- """Test simple comparisons of Builder objects
- """
- b1 = SCons.Builder.Builder(name="b1", src_suffix = '.o')
- b2 = SCons.Builder.Builder(name="b1", src_suffix = '.o')
- assert b1 == b2
- b3 = SCons.Builder.Builder(name="b3", src_suffix = '.x')
- assert b1 != b3
- assert b2 != b3
+ """Test simple comparisons of Builder objects
+ """
+ b1 = SCons.Builder.Builder(name="b1", src_suffix = '.o')
+ b2 = SCons.Builder.Builder(name="b1", src_suffix = '.o')
+ assert b1 == b2
+ b3 = SCons.Builder.Builder(name="b3", src_suffix = '.x')
+ assert b1 != b3
+ assert b2 != b3
def test_execute(self):
- """Test execution of simple Builder objects
-
- One Builder is a string that executes an external command,
- one is an internal Python function, one is a list
- containing one of each.
- """
+ """Test execution of simple Builder objects
+
+ One Builder is a string that executes an external command,
+ one is an internal Python function, one is a list
+ containing one of each.
+ """
def MyBuilder(**kw):
builder = apply(SCons.Builder.Builder, (), kw)
builder.action.show = no_show
return builder
- python = sys.executable
+ python = sys.executable
- cmd1 = r'%s %s %s xyzzy' % (python, act_py, outfile)
+ cmd1 = r'%s %s %s xyzzy' % (python, act_py, outfile)
builder = MyBuilder(action = cmd1, name = "cmd1")
- r = builder.execute()
- assert r == 0
- c = test.read(outfile, 'r')
+ r = builder.execute()
+ assert r == 0
+ c = test.read(outfile, 'r')
assert c == "act.py: 'xyzzy'\n", c
- cmd2 = r'%s %s %s $TARGET' % (python, act_py, outfile)
+ cmd2 = r'%s %s %s $TARGET' % (python, act_py, outfile)
builder = MyBuilder(action = cmd2, name = "cmd2")
- r = builder.execute(target = 'foo')
- assert r == 0
- c = test.read(outfile, 'r')
+ r = builder.execute(target = 'foo')
+ assert r == 0
+ c = test.read(outfile, 'r')
assert c == "act.py: 'foo'\n", c
- cmd3 = r'%s %s %s ${TARGETS}' % (python, act_py, outfile)
+ cmd3 = r'%s %s %s ${TARGETS}' % (python, act_py, outfile)
builder = MyBuilder(action = cmd3, name = "cmd3")
- r = builder.execute(target = ['aaa', 'bbb'])
- assert r == 0
- c = test.read(outfile, 'r')
+ r = builder.execute(target = ['aaa', 'bbb'])
+ assert r == 0
+ c = test.read(outfile, 'r')
assert c == "act.py: 'aaa' 'bbb'\n", c
- cmd4 = r'%s %s %s $SOURCES' % (python, act_py, outfile)
+ cmd4 = r'%s %s %s $SOURCES' % (python, act_py, outfile)
builder = MyBuilder(action = cmd4, name = "cmd4")
- r = builder.execute(source = ['one', 'two'])
- assert r == 0
- c = test.read(outfile, 'r')
+ r = builder.execute(source = ['one', 'two'])
+ assert r == 0
+ c = test.read(outfile, 'r')
assert c == "act.py: 'one' 'two'\n", c
- cmd4 = r'%s %s %s ${SOURCES[:2]}' % (python, act_py, outfile)
+ cmd4 = r'%s %s %s ${SOURCES[:2]}' % (python, act_py, outfile)
builder = MyBuilder(action = cmd4, name = "cmd4")
- r = builder.execute(source = ['three', 'four', 'five'])
- assert r == 0
- c = test.read(outfile, 'r')
+ r = builder.execute(source = ['three', 'four', 'five'])
+ assert r == 0
+ c = test.read(outfile, 'r')
assert c == "act.py: 'three' 'four'\n", c
- cmd5 = r'%s %s %s $TARGET XYZZY' % (python, act_py, outfile)
+ cmd5 = r'%s %s %s $TARGET XYZZY' % (python, act_py, outfile)
builder = MyBuilder(action = cmd5, name = "cmd5")
- r = builder.execute(target = 'out5', env = {'ENV' : {'XYZZY' : 'xyzzy'}})
- assert r == 0
- c = test.read(outfile, 'r')
+ r = builder.execute(target = 'out5', env = {'ENV' : {'XYZZY' : 'xyzzy'}})
+ assert r == 0
+ c = test.read(outfile, 'r')
assert c == "act.py: 'out5' 'XYZZY'\nact.py: 'xyzzy'\n", c
class Obj:
global count
count = 0
- def function1(**kw):
+ def function1(**kw):
global count
count = count + 1
if not type(kw['target']) is type([]):
kw['target'] = [ kw['target'] ]
for t in kw['target']:
- open(t, 'w').write("function1\n")
- return 1
+ open(t, 'w').write("function1\n")
+ return 1
- builder = MyBuilder(action = function1, name = "function1")
+ builder = MyBuilder(action = function1, name = "function1")
try:
r = builder.execute(target = [outfile, outfile2])
except SCons.Errors.BuildError:
assert r == 1
assert count == 1
c = test.read(outfile, 'r')
- assert c == "function1\n", c
+ assert c == "function1\n", c
c = test.read(outfile2, 'r')
- assert c == "function1\n", c
-
- class class1a:
- def __init__(self, **kw):
- open(kw['out'], 'w').write("class1a\n")
-
- builder = MyBuilder(action = class1a, name = "class1a")
- r = builder.execute(out = outfile)
- assert r.__class__ == class1a
- c = test.read(outfile, 'r')
- assert c == "class1a\n", c
-
- class class1b:
- def __call__(self, **kw):
- open(kw['out'], 'w').write("class1b\n")
- return 2
-
- builder = MyBuilder(action = class1b(), name = "class1b")
- r = builder.execute(out = outfile)
- assert r == 2
- c = test.read(outfile, 'r')
- assert c == "class1b\n", c
-
- cmd2 = r'%s %s %s syzygy' % (python, act_py, outfile)
-
- def function2(**kw):
- open(kw['out'], 'a').write("function2\n")
- return 0
-
- class class2a:
- def __call__(self, **kw):
- open(kw['out'], 'a').write("class2a\n")
- return 0
-
- class class2b:
- def __init__(self, **kw):
- open(kw['out'], 'a').write("class2b\n")
-
- builder = MyBuilder(action = [cmd2, function2, class2a(), class2b], name = "clist")
- r = builder.execute(out = outfile)
- assert r.__class__ == class2b
- c = test.read(outfile, 'r')
+ assert c == "function1\n", c
+
+ class class1a:
+ def __init__(self, **kw):
+ open(kw['out'], 'w').write("class1a\n")
+
+ builder = MyBuilder(action = class1a, name = "class1a")
+ r = builder.execute(out = outfile)
+ assert r.__class__ == class1a
+ c = test.read(outfile, 'r')
+ assert c == "class1a\n", c
+
+ class class1b:
+ def __call__(self, **kw):
+ open(kw['out'], 'w').write("class1b\n")
+ return 2
+
+ builder = MyBuilder(action = class1b(), name = "class1b")
+ r = builder.execute(out = outfile)
+ assert r == 2
+ c = test.read(outfile, 'r')
+ assert c == "class1b\n", c
+
+ cmd2 = r'%s %s %s syzygy' % (python, act_py, outfile)
+
+ def function2(**kw):
+ open(kw['out'], 'a').write("function2\n")
+ return 0
+
+ class class2a:
+ def __call__(self, **kw):
+ open(kw['out'], 'a').write("class2a\n")
+ return 0
+
+ class class2b:
+ def __init__(self, **kw):
+ open(kw['out'], 'a').write("class2b\n")
+
+ builder = MyBuilder(action = [cmd2, function2, class2a(), class2b], name = "clist")
+ r = builder.execute(out = outfile)
+ assert r.__class__ == class2b
+ c = test.read(outfile, 'r')
assert c == "act.py: 'syzygy'\nfunction2\nclass2a\nclass2b\n", c
if os.name == 'nt':
assert contents == "foo\177\036\000\177\037\000d\000\000Sbar", repr(contents)
def test_node_factory(self):
- """Test a Builder that creates nodes of a specified class
- """
- class Foo:
- pass
- def FooFactory(target):
+ """Test a Builder that creates nodes of a specified class
+ """
+ class Foo:
+ pass
+ def FooFactory(target):
global Foo
- return Foo(target)
- builder = SCons.Builder.Builder(name = "builder", node_factory = FooFactory)
- assert builder.target_factory is FooFactory
- assert builder.source_factory is FooFactory
+ return Foo(target)
+ builder = SCons.Builder.Builder(name = "builder", node_factory = FooFactory)
+ assert builder.target_factory is FooFactory
+ assert builder.source_factory is FooFactory
def test_target_factory(self):
- """Test a Builder that creates target nodes of a specified class
- """
- class Foo:
- pass
- def FooFactory(target):
+ """Test a Builder that creates target nodes of a specified class
+ """
+ class Foo:
+ pass
+ def FooFactory(target):
global Foo
- return Foo(target)
- builder = SCons.Builder.Builder(name = "builder", target_factory = FooFactory)
- assert builder.target_factory is FooFactory
- assert not builder.source_factory is FooFactory
+ return Foo(target)
+ builder = SCons.Builder.Builder(name = "builder", target_factory = FooFactory)
+ assert builder.target_factory is FooFactory
+ assert not builder.source_factory is FooFactory
def test_source_factory(self):
- """Test a Builder that creates source nodes of a specified class
- """
- class Foo:
- pass
- def FooFactory(source):
+ """Test a Builder that creates source nodes of a specified class
+ """
+ class Foo:
+ pass
+ def FooFactory(source):
global Foo
- return Foo(source)
- builder = SCons.Builder.Builder(name = "builder", source_factory = FooFactory)
- assert not builder.target_factory is FooFactory
- assert builder.source_factory is FooFactory
+ return Foo(source)
+ builder = SCons.Builder.Builder(name = "builder", source_factory = FooFactory)
+ assert not builder.target_factory is FooFactory
+ assert builder.source_factory is FooFactory
def test_prefix(self):
- """Test Builder creation with a specified target prefix
-
- Make sure that there is no '.' separator appended.
- """
- builder = SCons.Builder.Builder(name = "builder", prefix = 'lib.')
- assert builder.prefix == 'lib.'
- builder = SCons.Builder.Builder(name = "builder", prefix = 'lib')
- assert builder.prefix == 'lib'
- tgt = builder(env, target = 'tgt1', source = 'src1')
- assert tgt.path == 'libtgt1', \
- "Target has unexpected name: %s" % tgt.path
+ """Test Builder creation with a specified target prefix
+
+ Make sure that there is no '.' separator appended.
+ """
+ builder = SCons.Builder.Builder(name = "builder", prefix = 'lib.')
+ assert builder.prefix == 'lib.'
+ builder = SCons.Builder.Builder(name = "builder", prefix = 'lib')
+ assert builder.prefix == 'lib'
+ tgt = builder(env, target = 'tgt1', source = 'src1')
+ assert tgt.path == 'libtgt1', \
+ "Target has unexpected name: %s" % tgt.path
tgts = builder(env, target = 'tgt2a tgt2b', source = 'src2')
assert tgts[0].path == 'libtgt2a', \
"Target has unexpected name: %s" % tgts[0].path
assert b5.src_suffixes(env) == ['.y'], b5.src_suffixes(env)
def test_suffix(self):
- """Test Builder creation with a specified target suffix
-
- Make sure that the '.' separator is appended to the
- beginning if it isn't already present.
- """
- builder = SCons.Builder.Builder(name = "builder", suffix = '.o')
- assert builder.suffix == '.o'
- builder = SCons.Builder.Builder(name = "builder", suffix = 'o')
- assert builder.suffix == '.o'
- tgt = builder(env, target = 'tgt3', source = 'src3')
- assert tgt.path == 'tgt3.o', \
- "Target has unexpected name: %s" % tgt[0].path
+ """Test Builder creation with a specified target suffix
+
+ Make sure that the '.' separator is appended to the
+ beginning if it isn't already present.
+ """
+ builder = SCons.Builder.Builder(name = "builder", suffix = '.o')
+ assert builder.suffix == '.o'
+ builder = SCons.Builder.Builder(name = "builder", suffix = 'o')
+ assert builder.suffix == '.o'
+ tgt = builder(env, target = 'tgt3', source = 'src3')
+ assert tgt.path == 'tgt3.o', \
+ "Target has unexpected name: %s" % tgt[0].path
tgts = builder(env, target = 'tgt4a tgt4b', source = 'src4')
assert tgts[0].path == 'tgt4a.o', \
"Target has unexpected name: %s" % tgts[0].path
builder = SCons.Builder.Builder(action = function2, name = "function2")
tgts = builder(env, target = [outfile, outfile2], source = 'foo')
- try:
+ try:
r = tgts[0].builder.execute(target = tgts)
- except SCons.Errors.BuildError:
+ except SCons.Errors.BuildError:
pass
c = test.read(outfile, 'r')
assert c == "function2\n", c
"""Testing ability to set a target scanner through a builder."""
global instanced
class TestScanner:
- def instance(self, env):
- global instanced
- instanced = 1
- return self
+ pass
scn = TestScanner()
builder = SCons.Builder.Builder(name = "builder", scanner=scn)
tgt = builder(env, target='foo', source='bar')
- assert tgt.scanner == scn, tgt.scanner
- assert instanced
+ assert tgt.target_scanner == scn, tgt.target_scanner
- instanced = None
builder1 = SCons.Builder.Builder(name = "builder1",
action='foo',
src_suffix='.bar',
src_builder = builder1,
scanner = scn)
tgt = builder2(env, target='baz', source='test.bar test2.foo test3.txt')
- assert tgt.scanner == scn, tgt.scanner
- assert instanced
+ assert tgt.target_scanner == scn, tgt.target_scanner
def test_src_scanner(slf):
"""Testing ability to set a source file scanner through a builder."""
env_scanner = TestScanner()
builder = SCons.Builder.Builder(name = "builder", action='action')
tgt = builder(env, target='foo.x', source='bar')
- assert tgt.scanner != env_scanner, tgt.scanner
- assert tgt.src_scanners[''] == env_scanner, tgt.src_scanners
+ src = tgt.sources[0]
+ assert tgt.target_scanner != env_scanner, tgt.target_scanner
+ assert src.source_scanner == env_scanner
if __name__ == "__main__":
suite = unittest.makeSuite(BuilderTestCase, 'test_')
if not unittest.TextTestRunner().run(suite).wasSuccessful():
- sys.exit(1)
+ sys.exit(1)
def getcwd(self):
self.__setTopLevelDir()
- return self._cwd
+ return self._cwd
def __checkClass(self, node, klass):
if klass == Entry:
"""This method differs from the File and Dir factory methods in
one important way: the meaning of the directory parameter.
In this method, if directory is None or not supplied, the supplied
- name is expected to be an absolute path. If you try to look up a
- relative path with directory=None, then an AssertionError will be
- raised."""
+ name is expected to be an absolute path. If you try to look up a
+ relative path with directory=None, then an AssertionError will be
+ raised."""
if not name:
# This is a stupid hack to compensate for the fact
"""
def __init__(self, name, directory):
- """Initialize a generic file system Entry.
-
- Call the superclass initialization, take care of setting up
- our relative and absolute paths, identify our parent
- directory, and indicate that this node should use
- signatures."""
+ """Initialize a generic file system Entry.
+
+ Call the superclass initialization, take care of setting up
+ our relative and absolute paths, identify our parent
+ directory, and indicate that this node should use
+ signatures."""
SCons.Node.Node.__init__(self)
self.name = name
self.path_ = self.path
self.abspath_ = self.abspath
self.dir = directory
- self.use_signature = 1
+ self.use_signature = 1
self.__doSrcpath(self.duplicate)
self.srcpath_ = self.srcpath
+ self.cwd = None # will hold the SConscript directory for target nodes
def get_dir(self):
return self.dir
self.srcpath = self.dir.srcpath_ + self.name
def __str__(self):
- """A FS node's string representation is its path name."""
+ """A FS node's string representation is its path name."""
if self.duplicate or self.builder:
return self.path
else:
def __init__(self, name, directory):
Entry.__init__(self, name, directory)
- self._morph()
+ self._morph()
def _morph(self):
- """Turn a file system node (either a freshly initialized
- directory object or a separate Entry object) into a
- proper directory object.
-
- Modify our paths to add the trailing slash that indicates
- a directory. Set up this directory's entries and hook it
- into the file system tree. Specify that directories (this
- node) don't use signatures for currency calculation."""
+ """Turn a file system node (either a freshly initialized
+ directory object or a separate Entry object) into a
+ proper directory object.
+
+ Modify our paths to add the trailing slash that indicates
+ a directory. Set up this directory's entries and hook it
+ into the file system tree. Specify that directories (this
+ node) don't use signatures for currency calculation."""
self.path_ = self.path + os.sep
self.abspath_ = self.abspath + os.sep
else:
return self.entries['..'].root()
- def children(self, scanner):
- #XXX --random: randomize "dependencies?"
- keys = filter(lambda k: k != '.' and k != '..', self.entries.keys())
- kids = map(lambda x, s=self: s.entries[x], keys)
- def c(one, two):
+ def all_children(self, scanner):
+ #XXX --random: randomize "dependencies?"
+ keys = filter(lambda k: k != '.' and k != '..', self.entries.keys())
+ kids = map(lambda x, s=self: s.entries[x], keys)
+ def c(one, two):
if one.abspath < two.abspath:
return -1
if one.abspath > two.abspath:
return 1
return 0
- kids.sort(c)
- return kids
+ kids.sort(c)
+ return kids
def build(self):
"""A null "builder" for directories."""
.sconsign entry."""
return self.dir.sconsign().get(self.name)
- def scan(self, scanner = None):
- if not scanner:
- scanner = self.scanner
- if scanner and not self.scanned.has_key(scanner):
- deps = scanner.scan(self, self.env)
- self.add_implicit(deps, scanner)
- self.scanned[scanner] = 1
-
+ def get_implicit_deps(self, env, scanner, target):
+ if scanner:
+ return scanner.scan(self, env, target)
+ else:
+ return []
+
def exists(self):
if self.duplicate and not self.created:
self.created = 1
global scanner_count
scanner_count = scanner_count + 1
self.hash = scanner_count
- def scan(self, node, env):
+ def scan(self, node, env, target):
return [node]
def __hash__(self):
return self.hash
up_path = strip_slash(up_path_)
name = string.split(abspath, os.sep)[-1]
- assert dir.name == name, \
+ assert dir.name == name, \
"dir.name %s != expected name %s" % \
(dir.name, name)
assert dir.path == path, \
try:
f2 = fs.File(string.join(['f1', 'f2'], sep), directory = d1)
except TypeError, x:
- assert str(x) == ("Tried to lookup File '%s' as a Dir." %
- d1_f1), x
+ assert str(x) == ("Tried to lookup File '%s' as a Dir." %
+ d1_f1), x
except:
raise
try:
dir = fs.Dir(string.join(['d1', 'f1'], sep))
except TypeError, x:
- assert str(x) == ("Tried to lookup File '%s' as a Dir." %
- d1_f1), x
+ assert str(x) == ("Tried to lookup File '%s' as a Dir." %
+ d1_f1), x
except:
raise
assert str(x) == ("Tried to lookup Dir '%s' as a File." %
'd1'), x
except:
- raise
+ raise
# Test Dir.children()
dir = fs.Dir('ddd')
kids = map(lambda x: x.path, dir.children(None))
kids.sort()
assert kids == [os.path.join('ddd', 'd1'),
- os.path.join('ddd', 'f1'),
- os.path.join('ddd', 'f2'),
- os.path.join('ddd', 'f3')]
+ os.path.join('ddd', 'f1'),
+ os.path.join('ddd', 'f2'),
+ os.path.join('ddd', 'f3')]
kids = map(lambda x: x.path_, dir.children(None))
kids.sort()
assert kids == [os.path.join('ddd', 'd1', ''),
expect = string.replace(expect, '/', os.sep)
assert path == expect, "path %s != expected %s" % (path, expect)
- e1 = fs.Entry("d1")
- assert e1.__class__.__name__ == 'Dir'
+ e1 = fs.Entry("d1")
+ assert e1.__class__.__name__ == 'Dir'
match(e1.path, "d1")
match(e1.path_, "d1/")
match(e1.dir.path, ".")
- e2 = fs.Entry("d1/f1")
- assert e2.__class__.__name__ == 'File'
+ e2 = fs.Entry("d1/f1")
+ assert e2.__class__.__name__ == 'File'
match(e2.path, "d1/f1")
match(e2.path_, "d1/f1")
match(e2.dir.path, "d1")
- e3 = fs.Entry("e3")
- assert e3.__class__.__name__ == 'Entry'
+ e3 = fs.Entry("e3")
+ assert e3.__class__.__name__ == 'Entry'
match(e3.path, "e3")
match(e3.path_, "e3")
match(e3.dir.path, ".")
- e4 = fs.Entry("d1/e4")
- assert e4.__class__.__name__ == 'Entry'
+ e4 = fs.Entry("d1/e4")
+ assert e4.__class__.__name__ == 'Entry'
match(e4.path, "d1/e4")
match(e4.path_, "d1/e4")
match(e4.dir.path, "d1")
- e5 = fs.Entry("e3/e5")
- assert e3.__class__.__name__ == 'Dir'
+ e5 = fs.Entry("e3/e5")
+ assert e3.__class__.__name__ == 'Dir'
match(e3.path, "e3")
match(e3.path_, "e3/")
match(e3.dir.path, ".")
- assert e5.__class__.__name__ == 'Entry'
+ assert e5.__class__.__name__ == 'Entry'
match(e5.path, "e3/e5")
match(e5.path_, "e3/e5")
match(e5.dir.path, "e3")
- e6 = fs.Dir("d1/e4")
- assert e6 is e4
- assert e4.__class__.__name__ == 'Dir'
+ e6 = fs.Dir("d1/e4")
+ assert e6 is e4
+ assert e4.__class__.__name__ == 'Dir'
match(e4.path, "d1/e4")
match(e4.path_, "d1/e4/")
match(e4.dir.path, "d1")
- e7 = fs.File("e3/e5")
- assert e7 is e5
- assert e5.__class__.__name__ == 'File'
+ e7 = fs.File("e3/e5")
+ assert e7 is e5
+ assert e5.__class__.__name__ == 'File'
match(e5.path, "e3/e5")
match(e5.path_, "e3/e5")
match(e5.dir.path, "e3")
match(e13.path, "subdir/subdir/e13")
# Test scanning
- scn1 = Scanner()
- f1.scan(scn1)
- assert f1.implicit[scn1][0].path_ == os.path.join("d1", "f1")
- del f1.implicit[scn1]
- f1.scan(scn1)
- assert len(f1.implicit) == 0, f1.implicit
- del f1.scanned[scn1]
- f1.scan(scn1)
- assert f1.implicit[scn1][0].path_ == os.path.join("d1", "f1")
-
- # Test multiple scanners
- scn2 = Scanner()
- f2 = fs.File("f2")
- f2.scan(scn1)
- f2.scan(scn2)
- match(f2.implicit[scn1][0].path_, 'subdir/f2')
- match(f2.implicit[scn2][0].path_, 'subdir/f2')
+ f1.target_scanner = Scanner()
+ f1.scan()
+ assert f1.implicit[0].path_ == os.path.join("d1", "f1")
+ f1.implicit = []
+ f1.scan()
+ assert f1.implicit[0].path_ == os.path.join("d1", "f1")
# Test building a file whose directory is not there yet...
f1 = fs.File(test.workpath("foo/bar/baz/ack"))
os.chdir('..')
- # Test getcwd()
+ # Test getcwd()
fs = SCons.Node.FS.FS()
- assert str(fs.getcwd()) == ".", str(fs.getcwd())
- fs.chdir(fs.Dir('subdir'))
- assert str(fs.getcwd()) == "subdir", str(fs.getcwd())
- fs.chdir(fs.Dir('../..'))
- assert str(fs.getcwd()) == test.workdir, str(fs.getcwd())
+ assert str(fs.getcwd()) == ".", str(fs.getcwd())
+ fs.chdir(fs.Dir('subdir'))
+ assert str(fs.getcwd()) == "subdir", str(fs.getcwd())
+ fs.chdir(fs.Dir('../..'))
+ assert str(fs.getcwd()) == test.workdir, str(fs.getcwd())
f1 = fs.File(test.workpath("do_i_exist"))
assert not f1.exists()
class Builder:
def execute(self, **kw):
global built_it, built_target, built_source
- built_it = 1
+ built_it = 1
built_target = kw['target']
built_source = kw['source']
return 0
class NodeTestCase(unittest.TestCase):
def test_BuildException(self):
- """Test throwing an exception on build failure.
- """
- node = SCons.Node.Node()
- node.builder_set(FailBuilder())
- node.env_set(Environment())
- try:
- node.build()
- except SCons.Errors.BuildError:
- pass
- else:
- raise TestFailed, "did not catch expected BuildError"
+ """Test throwing an exception on build failure.
+ """
+ node = SCons.Node.Node()
+ node.builder_set(FailBuilder())
+ node.env_set(Environment())
+ try:
+ node.build()
+ except SCons.Errors.BuildError:
+ pass
+ else:
+ raise TestFailed, "did not catch expected BuildError"
node = SCons.Node.Node()
node.builder_set(ExceptBuilder())
raise TestFailed, "did not catch expected BuildError"
def test_build(self):
- """Test building a node
- """
+ """Test building a node
+ """
global built_it
class MyNode(SCons.Node.Node):
return self.path
def prepare(self):
self.prepare_count = self.prepare_count+ 1
- # Make sure it doesn't blow up if no builder is set.
+ # Make sure it doesn't blow up if no builder is set.
node = MyNode()
- node.build()
- assert built_it == None
+ node.build()
+ assert built_it == None
node = MyNode()
- node.builder_set(Builder())
- node.env_set(Environment())
+ node.builder_set(Builder())
+ node.env_set(Environment())
node.path = "xxx"
node.sources = ["yyy", "zzz"]
- node.build()
- assert built_it
+ node.build()
+ assert built_it
assert type(built_target) == type(MyNode()), type(built_target)
assert str(built_target) == "xxx", str(built_target)
assert built_source == ["yyy", "zzz"], built_source
assert str(built_target) == "fff", str(built_target)
assert built_source == ["hhh", "iii"], built_source
+ def test_depends_on(self):
+ parent = SCons.Node.Node()
+ child = SCons.Node.Node()
+ parent.add_dependency([child])
+ assert parent.depends_on([child])
+
def test_builder_set(self):
- """Test setting a Node's Builder
- """
- node = SCons.Node.Node()
- b = Builder()
- node.builder_set(b)
- assert node.builder == b
+ """Test setting a Node's Builder
+ """
+ node = SCons.Node.Node()
+ b = Builder()
+ node.builder_set(b)
+ assert node.builder == b
def test_builder_sig_adapter(self):
"""Test the node's adapter for builder signatures
assert node.current() is None
def test_env_set(self):
- """Test setting a Node's Environment
- """
- node = SCons.Node.Node()
- e = Environment()
- node.env_set(e)
- assert node.env == e
+ """Test setting a Node's Environment
+ """
+ node = SCons.Node.Node()
+ e = Environment()
+ node.env_set(e)
+ assert node.env == e
def test_set_bsig(self):
"""Test setting a Node's signature
assert node.precious == 7
def test_add_dependency(self):
- """Test adding dependencies to a Node's list.
- """
- node = SCons.Node.Node()
- assert node.depends == []
+ """Test adding dependencies to a Node's list.
+ """
+ node = SCons.Node.Node()
+ assert node.depends == []
zero = SCons.Node.Node()
try:
- node.add_dependency(zero)
- except TypeError:
- pass
+ node.add_dependency(zero)
+ except TypeError:
+ pass
else:
assert 0
def test_add_source(self):
- """Test adding sources to a Node's list.
- """
- node = SCons.Node.Node()
- assert node.sources == []
-
- zero = SCons.Node.Node()
- try:
- node.add_source(zero)
- except TypeError:
- pass
- else:
- assert 0
-
- one = SCons.Node.Node()
- two = SCons.Node.Node()
- three = SCons.Node.Node()
- four = SCons.Node.Node()
-
- node.add_source([one])
- assert node.sources == [one]
- node.add_source([two, three])
- assert node.sources == [one, two, three]
- node.add_source([three, four, one])
- assert node.sources == [one, two, three, four]
-
- assert zero.get_parents() == []
- assert one.get_parents() == [node]
- assert two.get_parents() == [node]
- assert three.get_parents() == [node]
- assert four.get_parents() == [node]
-
- def test_add_implicit(self):
- """Test adding implicit (scanned) dependencies to a Node's list.
+ """Test adding sources to a Node's list.
"""
node = SCons.Node.Node()
- assert node.implicit == {}
+ assert node.sources == []
zero = SCons.Node.Node()
try:
three = SCons.Node.Node()
four = SCons.Node.Node()
- node.add_implicit([one], 1)
- assert node.implicit[1] == [one]
- node.add_implicit([two, three], 1)
- assert node.implicit[1] == [one, two, three]
- node.add_implicit([three, four, one], 1)
- assert node.implicit[1] == [one, two, three, four]
+ node.add_source([one])
+ assert node.sources == [one]
+ node.add_source([two, three])
+ assert node.sources == [one, two, three]
+ node.add_source([three, four, one])
+ assert node.sources == [one, two, three, four]
assert zero.get_parents() == []
assert one.get_parents() == [node]
assert three.get_parents() == [node]
assert four.get_parents() == [node]
- node.add_implicit([one], 2)
- node.add_implicit([two, three], 3)
- node.add_implicit([three, four, one], 4)
-
- assert node.implicit[1] == [one, two, three, four]
- assert node.implicit[2] == [one]
- assert node.implicit[3] == [two, three]
- assert node.implicit[4] == [three, four, one]
-
def test_add_ignore(self):
"""Test adding files whose dependencies should be ignored.
"""
pass
ds=DummyScanner()
node = SCons.Node.Node()
- assert node.scanner == None, node.scanner
- node.scanner_set(ds)
- assert node.scanner == ds, node.scanner
- node.scan(ds)
- assert node.scanned[ds] == 1, node.scanned
-
- def test_src_scanner_set(self):
- """Test setting source-file Scanners"""
- class DummyScanner:
- pass
- ds1=DummyScanner()
- ds2=DummyScanner()
- node = SCons.Node.Node()
- assert node.src_scanners == {}, node.src_scanners
- node.src_scanner_set('a', ds1)
- assert node.src_scanners['a'] == ds1, node.src_scanners
- node.src_scanner_set('b', ds2)
- assert node.src_scanners['b'] == ds2, node.src_scanners
-
- def test_src_scanner_set(self):
- """Test setting source-file Scanners"""
- class DummyScanner:
- pass
- ds1=DummyScanner()
- ds2=DummyScanner()
- node = SCons.Node.Node()
- node.src_scanner_set('a', ds1)
- node.src_scanner_set('b', ds2)
- s = node.src_scanner_get(None)
- assert s == None, s
- s = node.src_scanner_get('a')
- assert s == ds1, s
- s = node.src_scanner_get('b')
- assert s == ds2, s
- s = node.src_scanner_get('c')
- assert s == None, s
+ assert node.target_scanner == None, node.target_scanner
+ node.target_scanner = ds
+ node.scan()
def test_scanner_key(self):
"""Test that a scanner_key() method exists"""
def test_children(self):
"""Test fetching the non-ignored "children" of a Node.
"""
- node = SCons.Node.Node()
+ node = SCons.Node.Node()
n1 = SCons.Node.Node()
n2 = SCons.Node.Node()
n3 = SCons.Node.Node()
node.add_source([n1, n2, n3])
node.add_dependency([n4, n5, n6])
- node.add_implicit([n7, n8, n9], 'key1')
- node.add_implicit([n10, n11, n12], 'key2')
+ node._add_child(node.implicit, [n7, n8, n9])
+ node._add_child(node.implicit, [n10, n11, n12])
node.add_ignore([n2, n5, n8, n11])
- kids = node.children(None)
+ kids = node.children()
for kid in [n1, n3, n4, n6, n7, n9, n10, n12]:
assert kid in kids, kid
for kid in [n2, n5, n8, n11]:
assert not kid in kids, kid
- kids = node.children('key1')
- for kid in [n1, n3, n4, n6, n7, n9]:
- assert kid in kids, kid
- for kid in [n2, n5, n8, n10, n11, n12]:
- assert not kid in kids, kid
-
- kids = node.children('key2')
- for kid in [n1, n3, n4, n6, n10, n12]:
- assert kid in kids, kid
- for kid in [n2, n5, n7, n8, n9, n11]:
- assert not kid in kids, kid
-
def test_all_children(self):
"""Test fetching all the "children" of a Node.
"""
node.add_source([n1, n2, n3])
node.add_dependency([n4, n5, n6])
- node.add_implicit([n7, n8, n9], 'key1')
- node.add_implicit([n10, n11, n12], 'key2')
+ node._add_child(node.implicit, [n7, n8, n9])
+ node._add_child(node.implicit, [n10, n11, n12])
node.add_ignore([n2, n5, n8, n11])
- kids = node.all_children(None)
+ kids = node.all_children()
for kid in [n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12]:
assert kid in kids
- kids = node.all_children('key1')
- for kid in [n1, n2, n3, n4, n5, n6, n7, n8, n9]:
- assert kid in kids
- for kid in [n10, n11, n12]:
- assert not kid in kids
-
- kids = node.all_children('key2')
- for kid in [n1, n2, n3, n4, n5, n6, n10, n11, n12]:
- assert kid in kids
- for kid in [n7, n8, n9]:
- assert not kid in kids
-
def test_state(self):
- """Test setting and getting the state of a node
- """
+ """Test setting and getting the state of a node
+ """
node = SCons.Node.Node()
assert node.get_state() == None
node.set_state(SCons.Node.executing)
assert SCons.Node.executed < SCons.Node.failed
def test_walker(self):
- """Test walking a Node tree.
- """
+ """Test walking a Node tree.
+ """
- class MyNode(SCons.Node.Node):
- def __init__(self, name):
- SCons.Node.Node.__init__(self)
- self.name = name
+ class MyNode(SCons.Node.Node):
+ def __init__(self, name):
+ SCons.Node.Node.__init__(self)
+ self.name = name
- n1 = MyNode("n1")
+ n1 = MyNode("n1")
- nw = SCons.Node.Walker(n1)
+ nw = SCons.Node.Walker(n1)
assert not nw.is_done()
- assert nw.next().name == "n1"
+ assert nw.next().name == "n1"
assert nw.is_done()
- assert nw.next() == None
-
- n2 = MyNode("n2")
- n3 = MyNode("n3")
- n1.add_source([n2, n3])
-
- nw = SCons.Node.Walker(n1)
- assert nw.next().name == "n2"
- assert nw.next().name == "n3"
- assert nw.next().name == "n1"
- assert nw.next() == None
-
- n4 = MyNode("n4")
- n5 = MyNode("n5")
- n6 = MyNode("n6")
- n7 = MyNode("n7")
- n2.add_source([n4, n5])
- n3.add_dependency([n6, n7])
-
- nw = SCons.Node.Walker(n1)
- assert nw.next().name == "n4"
- assert nw.next().name == "n5"
+ assert nw.next() == None
+
+ n2 = MyNode("n2")
+ n3 = MyNode("n3")
+ n1.add_source([n2, n3])
+
+ nw = SCons.Node.Walker(n1)
+ assert nw.next().name == "n2"
+ assert nw.next().name == "n3"
+ assert nw.next().name == "n1"
+ assert nw.next() == None
+
+ n4 = MyNode("n4")
+ n5 = MyNode("n5")
+ n6 = MyNode("n6")
+ n7 = MyNode("n7")
+ n2.add_source([n4, n5])
+ n3.add_dependency([n6, n7])
+
+ nw = SCons.Node.Walker(n1)
+ assert nw.next().name == "n4"
+ assert nw.next().name == "n5"
assert nw.history.has_key(n2)
- assert nw.next().name == "n2"
- assert nw.next().name == "n6"
- assert nw.next().name == "n7"
+ assert nw.next().name == "n2"
+ assert nw.next().name == "n6"
+ assert nw.next().name == "n7"
assert nw.history.has_key(n3)
- assert nw.next().name == "n3"
+ assert nw.next().name == "n3"
assert nw.history.has_key(n1)
- assert nw.next().name == "n1"
- assert nw.next() == None
+ assert nw.next().name == "n1"
+ assert nw.next() == None
n8 = MyNode("n8")
n8.add_dependency([n3])
n = nw.next()
assert nw.next() == None
- def test_children_are_executed(self):
- n1 = SCons.Node.Node()
- n2 = SCons.Node.Node()
- n3 = SCons.Node.Node()
- n4 = SCons.Node.Node()
-
- n4.add_source([n3])
- n3.add_source([n1, n2])
-
- assert not n4.children_are_executed(None)
- assert not n3.children_are_executed(None)
- assert n2.children_are_executed(None)
- assert n1.children_are_executed(None)
-
- n1.set_state(SCons.Node.executed)
- assert not n4.children_are_executed(None)
- assert not n3.children_are_executed(None)
- assert n2.children_are_executed(None)
- assert n1.children_are_executed(None)
-
- n2.set_state(SCons.Node.executed)
- assert not n4.children_are_executed(None)
- assert n3.children_are_executed(None)
- assert n2.children_are_executed(None)
- assert n1.children_are_executed(None)
-
- n3.set_state(SCons.Node.executed)
- assert n4.children_are_executed(None)
- assert n3.children_are_executed(None)
- assert n2.children_are_executed(None)
- assert n1.children_are_executed(None)
-
- def test_rescan(self):
- """Test that built node implicit dependencies are cleared
- to be rescanned."""
- class DummyScanner:
- pass
-
- class TestNode(SCons.Node.Node):
- def scan(self, scanner):
- if not self.scanned.has_key(scanner):
- n=SCons.Node.Node()
- n.scanner_set(scanner)
- self.add_implicit([ n ], scanner)
- self.scanned[scanner] = 1
- tn=TestNode()
- tn.builder_set(Builder())
- tn.env_set(Environment())
- ds = DummyScanner()
- tn.scan(ds)
- map(lambda x: x.scan(), tn.depends)
- assert tn.scanned[ds]
- assert len(tn.implicit[ds]) == 1, tn.implicit
- tn.scan(ds)
- assert tn.scanned[ds]
- assert len(tn.implicit[ds]) == 1, tn.implicit
- tn.build()
- assert not tn.scanned.has_key(ds)
- assert len(tn.implicit[ds]) == 1, tn.implicit
- tn.scan(ds)
- assert tn.scanned[ds]
- assert len(tn.implicit[ds]) == 2, tn.implicit
-
def test_arg2nodes(self):
"""Test the arg2nodes function."""
dict = {}
if __name__ == "__main__":
suite = unittest.makeSuite(NodeTestCase, 'test_')
if not unittest.TextTestRunner().run(suite).wasSuccessful():
- sys.exit(1)
+ sys.exit(1)
up_to_date = 3
executed = 4
failed = 5
+stack = 6 # nodes that are in the current Taskmaster execution stack
class Node:
"""The base Node class, for entities that we know how to
def __init__(self):
self.sources = [] # source files used to build node
self.depends = [] # explicit dependencies (from Depends)
- self.implicit = {} # implicit (scanned) dependencies
- self.ignore = [] # dependencies to ignore
+ self.implicit = [] # implicit (scanned) dependencies
+ self.ignore = [] # dependencies to ignore
self.parents = {}
self.wkids = None # Kids yet to walk, when it's an array
self.builder = None
- self.scanner = None # explicit scanner from this node's Builder
- self.scanned = {} # cached scanned values
- self.src_scanners = {} # scanners for this node's source files
+ self.source_scanner = None # implicit scanner from scanner map
+ self.target_scanner = None # explicit scanner from this node's Builder
self.env = None
self.state = None
self.bsig = None
self.use_signature = 1
self.precious = None
self.found_includes = {}
+ self.includes = None
def build(self):
"""Actually build the node. Return the status from the build."""
- if not self.builder:
- return None
+ # This method is called from multiple threads in a parallel build,
+ # so only do thread safe stuff here. Do thread unsafe stuff in built().
+ if not self.builder:
+ return None
try:
# If this Builder instance has already been called,
# there will already be an associated status.
if stat:
raise BuildError(node = self, errstr = "Error %d" % stat)
- self.found_includes = {}
-
- # If we successfully build a node, then we need to rescan for
- # implicit dependencies, since it might have changed on us.
- self.scanned = {}
-
return stat
+ def built(self):
+ """Called just after this node is sucessfully built."""
+ # Clear out the implicit dependency caches:
+ # XXX this really should somehow be made more general and put
+ # under the control of the scanners.
+ if self.source_scanner:
+ self.found_includes = {}
+ self.includes = None
+
+ def get_parents(node, parent): return node.get_parents()
+ def clear_cache(node, parent):
+ node.implicit = []
+ w = Walker(self, get_parents, ignore_cycle, clear_cache)
+ while w.next(): pass
+
+ def depends_on(self, nodes):
+ """Does this node depend on any of 'nodes'?"""
+ for node in nodes:
+ if node in self.children():
+ return 1
+
+ return 0
+
def builder_set(self, builder):
- self.builder = builder
+ self.builder = builder
def builder_sig_adapter(self):
"""Create an adapter for calculating a builder's signature.
return self.node.builder.get_contents(env = dict)
return Adapter(self)
- def scanner_set(self, scanner):
- self.scanner = scanner
-
- def src_scanner_set(self, key, scanner):
- self.src_scanners[key] = scanner
-
- def src_scanner_get(self, key):
- return self.src_scanners.get(key, None)
-
- def scan(self, scanner = None):
- if not scanner:
- scanner = self.scanner
- self.scanned[scanner] = 1
+ def get_implicit_deps(self, env, scanner, target):
+ """Return a list of implicit dependencies for this node"""
+ return []
+
+ def scan(self):
+ """Scan this node's dependents for implicit dependencies."""
+ # Don't bother scanning non-derived files, because we don't
+ # care what their dependencies are.
+ # Don't scan again, if we already have scanned.
+ if self.builder and not self.implicit:
+ for child in self.children(scan=0):
+ self._add_child(self.implicit, child.get_implicit_deps(self.env, child.source_scanner, self))
+
+ # scan this node itself for implicit dependencies
+ self._add_child(self.implicit, self.get_implicit_deps(self.env, self.target_scanner, self))
def scanner_key(self):
return None
def env_set(self, env, safe=0):
if safe and self.env:
return
- self.env = env
+ self.env = env
def get_bsig(self):
"""Get the node's build signature (based on the signatures
pass
def add_dependency(self, depend):
- """Adds dependencies. The depend argument must be a list."""
+ """Adds dependencies. The depend argument must be a list."""
self._add_child(self.depends, depend)
def add_ignore(self, depend):
self._add_child(self.ignore, depend)
def add_source(self, source):
- """Adds sources. The source argument must be a list."""
+ """Adds sources. The source argument must be a list."""
self._add_child(self.sources, source)
- def add_implicit(self, implicit, key):
- """Adds implicit (scanned) dependencies. The implicit
- argument must be a list."""
- if not self.implicit.has_key(key):
- self.implicit[key] = []
- self._add_child(self.implicit[key], implicit)
-
def _add_child(self, collection, child):
"""Adds 'child' to 'collection'. The 'child' argument must be a list"""
if type(child) is not type([]):
raise TypeError("child must be a list")
- child = filter(lambda x, s=collection: x not in s, child)
- if child:
- collection.extend(child)
+ child = filter(lambda x, s=collection: x not in s, child)
+ if child:
+ collection.extend(child)
for c in child:
c.parents[self] = 1
if self.wkids != None:
self.wkids.append(wkid)
- def children(self, scanner):
+ def children(self, scan=1):
"""Return a list of the node's direct children, minus those
that are ignored by this node."""
return filter(lambda x, i=self.ignore: x not in i,
- self.all_children(scanner))
+ self.all_children(scan))
- def all_children(self, scanner):
+ def all_children(self, scan=1):
"""Return a list of all the node's direct children."""
#XXX Need to remove duplicates from this
- if not self.implicit.has_key(scanner):
- self.scan(scanner)
- if scanner:
- implicit = self.implicit[scanner]
- else:
- implicit = reduce(lambda x, y: x + y, self.implicit.values(), [])
- return self.sources + self.depends + implicit
+ if scan and not self.implicit:
+ self.scan()
+ return self.sources + self.depends + self.implicit
def get_parents(self):
return self.parents.keys()
def current(self):
return None
- def children_are_executed(self, scanner):
- return reduce(lambda x,y: ((y.get_state() == executed
- or y.get_state() == up_to_date)
- and x),
- self.children(scanner),
- 1)
-
-def get_children(node, parent): return node.children(None)
+def get_children(node, parent): return node.children()
def ignore_cycle(node, stack): pass
def do_nothing(node, parent): pass
self.history[node] = None
def next(self):
- """Return the next node for this walk of the tree.
+ """Return the next node for this walk of the tree.
- This function is intentionally iterative, not recursive,
- to sidestep any issues of stack size limitations.
- """
+ This function is intentionally iterative, not recursive,
+ to sidestep any issues of stack size limitations.
+ """
- while self.stack:
+ while self.stack:
if self.stack[-1].wkids:
node = self.stack[-1].wkids.pop(0)
if not self.stack[-1].wkids:
include_re = re.compile('^[ \t]*#[ \t]*include[ \t]+(<|")([\\w./\\\\]+)(>|")', re.M)
-include_cache = {}
-
def CScan(fs = SCons.Node.FS.default_fs):
"""Return a prototype Scanner instance for scanning source files
that use the C pre-processor"""
- cs = CScanner(scan, "CScan", [fs, ()],
- [".c", ".C", ".cxx", ".cpp", ".c++", ".cc",
- ".h", ".H", ".hxx", ".hpp", ".hh",
- ".F", ".fpp", ".FPP"])
- cs.fs = fs
+ cs = SCons.Scanner.Recursive(scan, "CScan", fs,
+ [".c", ".C", ".cxx", ".cpp", ".c++", ".cc",
+ ".h", ".H", ".hxx", ".hpp", ".hh",
+ ".F", ".fpp", ".FPP"])
return cs
-class CScanner(SCons.Scanner.Recursive):
- def __init__(self, *args, **kw):
- apply(SCons.Scanner.Recursive.__init__, (self,) + args, kw)
- self.hash = None
- self.pathscanners = {}
-
- def instance(self, env):
- """
- Return a unique instance of a C scanner object for a
- given environment.
- """
- try:
- dirs = tuple(SCons.Node.arg2nodes(env.Dictionary('CPPPATH'),
- self.fs.Dir))
- except:
- dirs = ()
- if not self.pathscanners.has_key(dirs):
- clone = copy.copy(self)
- clone.hash = dirs
- clone.argument = [self.fs, dirs] # XXX reaching into object
- self.pathscanners[dirs] = clone
- return self.pathscanners[dirs]
-
- def __hash__(self):
- return hash(self.hash)
-
-def scan(node, env, args = [SCons.Node.FS.default_fs, ()]):
+def scan(node, env, target, fs = SCons.Node.FS.default_fs):
"""
scan(node, Environment) -> [node]
dependencies.
"""
- fs, cpppath = args
+ # This function caches various information in node and target:
+ # target.cpppath - env['CPPPATH'] converted to nodes
+ # node.found_includes - include files found by previous call to scan,
+ # keyed on cpppath
+ # node.includes - the result of include_re.findall()
+
+ if not hasattr(target, 'cpppath'):
+ def Dir(x, dir=target.cwd, fs=fs): return fs.Dir(x,dir)
+ try:
+ target.cpppath = tuple(SCons.Node.arg2nodes(env['CPPPATH'],Dir))
+ except KeyError:
+ target.cpppath = ()
+
+ cpppath = target.cpppath
+
nodes = []
try:
if node.exists():
# cache the includes list in node so we only scan it once:
- if hasattr(node, 'includes'):
+ if node.includes != None:
includes = node.includes
else:
includes = include_re.findall(node.get_contents())
# define some helpers:
+class DummyTarget:
+ def __init__(self, cwd=None):
+ self.cwd = cwd
+
class DummyEnvironment:
def __init__(self, listCppPath):
self.path = listCppPath
else:
raise KeyError, "Dummy environment only has CPPPATH attribute."
+ def __getitem__(self,key):
+ return self.Dictionary()[key]
+
+ def __setitem__(self,key,value):
+ self.Dictionary()[key] = value
+
+ def __delitem__(self,key):
+ del self.Dictionary()[key]
+
def deps_match(self, deps, headers):
scanned = map(os.path.normpath, map(str, deps))
expect = map(os.path.normpath, headers)
def runTest(self):
env = DummyEnvironment([])
s = SCons.Scanner.C.CScan()
- deps = s.instance(env).scan(make_node('f1.cpp'), env)
- headers = ['f1.h', 'f2.h', 'fi.h']
+ deps = s.scan(make_node('f1.cpp'), env, DummyTarget())
+ headers = ['f1.h', 'f2.h', 'fi.h']
deps_match(self, deps, map(test.workpath, headers))
class CScannerTestCase2(unittest.TestCase):
def runTest(self):
env = DummyEnvironment([test.workpath("d1")])
s = SCons.Scanner.C.CScan()
- deps = s.instance(env).scan(make_node('f1.cpp'), env)
+ deps = s.scan(make_node('f1.cpp'), env, DummyTarget())
headers = ['d1/f2.h', 'f1.h']
deps_match(self, deps, map(test.workpath, headers))
def runTest(self):
env = DummyEnvironment([test.workpath("d1")])
s = SCons.Scanner.C.CScan()
- deps = s.instance(env).scan(make_node('f2.cpp'), env)
+ deps = s.scan(make_node('f2.cpp'), env, DummyTarget())
headers = ['d1/d2/f1.h', 'd1/f1.h', 'f1.h']
deps_match(self, deps, map(test.workpath, headers))
def runTest(self):
env = DummyEnvironment([test.workpath("d1"), test.workpath("d1/d2")])
s = SCons.Scanner.C.CScan()
- deps = s.instance(env).scan(make_node('f2.cpp'), env)
+ deps = s.scan(make_node('f2.cpp'), env, DummyTarget())
headers = ['d1/d2/f1.h', 'd1/d2/f4.h', 'd1/f1.h', 'f1.h']
deps_match(self, deps, map(test.workpath, headers))
def runTest(self):
env = DummyEnvironment([])
s = SCons.Scanner.C.CScan()
- deps = s.instance(env).scan(make_node('f3.cpp'), env)
+ deps = s.scan(make_node('f3.cpp'), env, DummyTarget())
# Make sure exists() gets called on the file node being
# scanned, essential for cooperation with BuildDir functionality.
env2 = DummyEnvironment([test.workpath("d1/d2")])
env3 = DummyEnvironment([test.workpath("d1/../d1")])
s = SCons.Scanner.C.CScan()
- s1 = s.instance(env1)
- s2 = s.instance(env2)
- s3 = s.instance(env3)
- assert not s1 is s2
- assert s1 is s3
- deps1 = s1.scan(make_node('f1.cpp'), None)
- deps2 = s2.scan(make_node('f1.cpp'), None)
+ deps1 = s.scan(make_node('f1.cpp'), env1, DummyTarget())
+ deps2 = s.scan(make_node('f1.cpp'), env2, DummyTarget())
headers1 = ['d1/f2.h', 'f1.h']
headers2 = ['d1/d2/f2.h', 'f1.h']
deps_match(self, deps1, map(test.workpath, headers1))
deps_match(self, deps2, map(test.workpath, headers2))
-class CScannerTestCase7(unittest.TestCase):
- def runTest(self):
- s = SCons.Scanner.C.CScan()
- s1 = s.instance(DummyEnvironment([test.workpath("d1")]))
- s2 = s.instance(DummyEnvironment([test.workpath("d1/../d1")]))
- dict = {}
- dict[s1] = 777
- assert dict[s2] == 777
-
class CScannerTestCase8(unittest.TestCase):
def runTest(self):
fs = SCons.Node.FS.FS(test.workpath(''))
env = DummyEnvironment(["include"])
s = SCons.Scanner.C.CScan(fs = fs)
- deps1 = s.instance(env).scan(fs.File('fa.cpp'), None)
+ deps1 = s.scan(fs.File('fa.cpp'), env, DummyTarget())
fs.chdir(fs.Dir('subdir'))
- deps2 = s.instance(env).scan(fs.File('#fa.cpp'), None)
+ target = DummyTarget(fs.getcwd())
+ fs.chdir(fs.Dir('..'))
+ deps2 = s.scan(fs.File('#fa.cpp'), env, target)
headers1 = ['include/fa.h', 'include/fb.h']
headers2 = ['subdir/include/fa.h', 'subdir/include/fb.h']
deps_match(self, deps1, headers1)
fs = SCons.Node.FS.FS(test.workpath(''))
s = SCons.Scanner.C.CScan(fs=fs)
env = DummyEnvironment([])
- deps = s.instance(env).scan(fs.File('fa.cpp'), None)
+ deps = s.scan(fs.File('fa.cpp'), env, DummyTarget())
deps_match(self, deps, [ 'fa.h' ])
test.unlink('fa.h')
s = SCons.Scanner.C.CScan(fs=fs)
env = DummyEnvironment([])
test.write('include/fa.cpp', test.read('fa.cpp'))
- deps = s.instance(env).scan(fs.File('#include/fa.cpp'), None)
+ deps = s.scan(fs.File('#include/fa.cpp'), env, DummyTarget())
deps_match(self, deps, [ 'include/fa.h', 'include/fb.h' ])
test.unlink('include/fa.cpp')
suite.addTest(CScannerTestCase4())
suite.addTest(CScannerTestCase5())
suite.addTest(CScannerTestCase6())
- suite.addTest(CScannerTestCase7())
suite.addTest(CScannerTestCase8())
suite.addTest(CScannerTestCase9())
suite.addTest(CScannerTestCase10())
import SCons.Scanner
import SCons.Util
-class NullProgScanner:
- """A do-nothing ProgScanner for Environments that have no LIBS."""
- def scan(node, env, args = []):
- return []
-
-null_scanner = NullProgScanner()
-
def ProgScan(fs = SCons.Node.FS.default_fs):
"""Return a prototype Scanner instance for scanning executable
files for static-lib dependencies"""
- ps = ProgScanner(scan, "ProgScan")
- ps.fs = fs
+ ps = SCons.Scanner.Base(scan, "ProgScan", fs)
return ps
-class ProgScanner(SCons.Scanner.Base):
- def __init__(self, *args, **kw):
- apply(SCons.Scanner.Base.__init__, (self,) + args, kw)
- self.hash = None
- self.pathscanners = {}
-
- def instance(self, env):
- """
- Return a unique instance of a Prog scanner object for a
- given environment.
- """
- try:
- libs = env.Dictionary('LIBS')
- except KeyError:
- # There are no LIBS in this environment, so just return the
- # fake "scanner" instance that always returns a null list.
- return null_scanner
- if SCons.Util.is_String(libs):
- libs = string.split(libs)
+def scan(node, env, target, fs):
+ """
+ This scanner scans program files for static-library
+ dependencies. It will search the LIBPATH environment variable
+ for libraries specified in the LIBS variable, returning any
+ files it finds as dependencies.
+ """
- try:
- dirs = tuple(SCons.Node.arg2nodes(env.Dictionary('LIBPATH'),
- self.fs.Dir))
- except:
- dirs = ()
+ # This function caches information in target:
+ # target.libpath - env['LIBPATH'] converted to nodes
+ if not hasattr(target, 'libpath'):
+ def Dir(x, dir=target.cwd, fs=fs): return fs.Dir(x,dir)
try:
- prefix = env.Dictionary('LIBPREFIX')
+ target.libpath = tuple(SCons.Node.arg2nodes(env['LIBPATH'],Dir))
except KeyError:
- prefix = ''
+ target.libpath = ()
+
+ libpath = target.libpath
- try:
- suffix = env.Dictionary('LIBSUFFIX')
- except KeyError:
- suffix = ''
+ try:
+ libs = env.Dictionary('LIBS')
+ except KeyError:
+ # There are no LIBS in this environment, so just return a null list:
+ return []
+ if SCons.Util.is_String(libs):
+ libs = string.split(libs)
- key = (dirs, tuple(libs), prefix, suffix)
- if not self.pathscanners.has_key(key):
- clone = copy.copy(self)
- clone.hash = key
- clone.argument = [self.fs, dirs, libs, prefix, suffix] # XXX reaching into object
- self.pathscanners[key] = clone
- return self.pathscanners[key]
+ try:
+ prefix = env.Dictionary('LIBPREFIX')
+ except KeyError:
+ prefix = ''
- def __hash__(self):
- return hash(self.hash)
+ try:
+ suffix = env.Dictionary('LIBSUFFIX')
+ except KeyError:
+ suffix = ''
-def scan(node, env, args = [SCons.Node.FS.default_fs, (), [], '', '']):
- """
- This scanner scans program files for static-library
- dependencies. It will search the LIBPATH environment variable
- for libraries specified in the LIBS variable, returning any
- files it finds as dependencies.
- """
- fs, libpath, libs, prefix, suffix = args
libs = map(lambda x, s=suffix, p=prefix: p + x + s, libs)
return SCons.Node.FS.find_files(libs, libpath, fs.File)
# define some helpers:
+class DummyTarget:
+ def __init__(self, cwd=None):
+ self.cwd = cwd
+
class DummyEnvironment:
def __init__(self, **kw):
self._dict = kw
return self._dict[args[0]]
else:
return map(lambda x, s=self: s._dict[x], args)
+ def __getitem__(self,key):
+ return self.Dictionary()[key]
+
+ def __setitem__(self,key,value):
+ self.Dictionary()[key] = value
+
+ def __delitem__(self,key):
+ del self.Dictionary()[key]
def deps_match(deps, libs):
deps=map(str, deps)
env = DummyEnvironment(LIBPATH=[ test.workpath("") ],
LIBS=[ 'l1', 'l2', 'l3' ])
s = SCons.Scanner.Prog.ProgScan()
- deps = s.instance(env).scan('dummy', env)
+ deps = s.scan('dummy', env, DummyTarget())
assert deps_match(deps, ['l1.lib']), map(str, deps)
class ProgScanTestCase2(unittest.TestCase):
["", "d1", "d1/d2" ]),
LIBS=[ 'l1', 'l2', 'l3' ])
s = SCons.Scanner.Prog.ProgScan()
- deps = s.instance(env).scan('dummy', env)
+ deps = s.scan('dummy', env, DummyTarget())
assert deps_match(deps, ['l1.lib', 'd1/l2.lib', 'd1/d2/l3.lib' ]), map(str, deps)
class ProgScanTestCase3(unittest.TestCase):
test.workpath("d1"),
LIBS='l2 l3')
s = SCons.Scanner.Prog.ProgScan()
- deps = s.instance(env).scan('dummy', env)
+ deps = s.scan('dummy', env, DummyTarget())
assert deps_match(deps, ['d1/l2.lib', 'd1/d2/l3.lib']), map(str, deps)
def suite():
test.workpath("d1"),
LIBS=u'l2 l3')
s = SCons.Scanner.Prog.ProgScan()
- deps = s.instance(env).scan('dummy', env)
+ deps = s.scan('dummy', env, DummyTarget())
assert deps_match(deps, ['d1/l2.lib', 'd1/d2/l3.lib']), map(str, deps)
suite.addTest(ProgScanTestCase4())
\n"""
import SCons.Scanner
import sys
+class DummyTarget:
+ cwd = None
+
+
class ScannerTestBase:
- def func(self, filename, env, *args):
+ def func(self, filename, env, target, *args):
self.filename = filename
self.env = env
+ self.target = target
if len(args) > 0:
self.arg = args[0]
def test(self, scanner, env, filename, deps, *args):
self.deps = deps
- scanned = scanner.scan(filename, env)
+ scanned = scanner.scan(filename, env, DummyTarget())
scanned_strs = map(lambda x: str(x), scanned)
self.failUnless(self.filename == filename, "the filename was passed incorrectly")
env.VARIABLE = "var1"
self.test(s, env, 'f1.cpp', ['f1.h', 'f1.hpp'])
- env = DummyEnvironment()
- env.VARIABLE = "i1"
- i = s.instance(env)
- self.test(i, env, 'i1.cpp', ['i1.h', 'i1.hpp'])
+ env = DummyEnvironment()
+ env.VARIABLE = "i1"
+ self.test(s, env, 'i1.cpp', ['i1.h', 'i1.hpp'])
class ScannerKeywordTestCase(ScannerTestBase, unittest.TestCase):
"Test the Scanner.Base class using the keyword argument"
env.VARIABLE = "var2"
self.test(s, env, 'f2.cpp', ['f2.h', 'f2.hpp'])
- env = DummyEnvironment()
- env.VARIABLE = "i2"
- i = s.instance(env)
- self.test(i, env, 'i2.cpp', ['i2.h', 'i2.hpp'])
+ env = DummyEnvironment()
+ env.VARIABLE = "i2"
+ self.test(s, env, 'i2.cpp', ['i2.h', 'i2.hpp'])
class ScannerPositionalArgumentTestCase(ScannerTestBase, unittest.TestCase):
"Test the Scanner.Base class using both position and optional arguments"
env.VARIABLE = "var3"
self.test(s, env, 'f3.cpp', ['f3.h', 'f3.hpp'], arg)
- env = DummyEnvironment()
- env.VARIABLE = "i3"
- i = s.instance(env)
- self.test(i, env, 'i3.cpp', ['i3.h', 'i3.hpp'], arg)
+ env = DummyEnvironment()
+ env.VARIABLE = "i3"
+ self.test(s, env, 'i3.cpp', ['i3.h', 'i3.hpp'], arg)
class ScannerKeywordArgumentTestCase(ScannerTestBase, unittest.TestCase):
"Test the Scanner.Base class using both keyword and optional arguments"
env.VARIABLE = "var4"
self.test(s, env, 'f4.cpp', ['f4.h', 'f4.hpp'], arg)
- env = DummyEnvironment()
- env.VARIABLE = "i4"
- i = s.instance(env)
- self.test(i, env, 'i4.cpp', ['i4.h', 'i4.hpp'], arg)
+ env = DummyEnvironment()
+ env.VARIABLE = "i4"
+ self.test(s, env, 'i4.cpp', ['i4.h', 'i4.hpp'], arg)
class ScannerHashTestCase(ScannerTestBase, unittest.TestCase):
"Test the Scanner.Base class __hash__() method"
self.skeys = skeys
self.node_factory = node_factory
- def scan(self, node, env):
+ def scan(self, node, env, target):
"""
This method scans a single object. 'node' is the node
that will be passed to the scanner function, and 'env' is the
"""
if not self.argument is _null:
- list = self.function(node, env, self.argument)
+ list = self.function(node, env, target, self.argument)
else:
- list = self.function(node, env)
+ list = self.function(node, env, target)
kw = {}
if hasattr(node, 'dir'):
kw['directory'] = node.dir
nodes.append(l)
return nodes
- def instance(self, env):
- """
- Return an instance of a Scanner object for use in scanning.
-
- In the base class, we just return the scanner itself.
- Other Scanner classes may use this to clone copies and/or
- return unique instances as needed.
- """
- return self
-
def __cmp__(self, other):
return cmp(self.__dict__, other.__dict__)
list of all dependencies.
"""
- def scan(self, node, env):
+ def scan(self, node, env, target):
"""
This method does the actual scanning. 'node' is the node
that will be passed to the scanner function, and 'env' is the
while nodes:
n = nodes.pop(0)
d = filter(lambda x, seen=seen: not seen.has_key(x),
- Base.scan(self, n, env))
+ Base.scan(self, n, env, target))
if d:
deps.extend(d)
nodes.extend(d)
self.file = file
self.path = file.path
self.builder = file.builder
- self.depends = []
+ self.depends = []
self.ignore = []
self.use_signature = 1
self.bsig = None
self.exists_cache = self.exists()
return self.exists_cache
- def children(self, scanner):
+ def children(self):
return filter(lambda x, i=self.ignore: x not in i,
self.sources + self.depends)
- def all_children(self, scanner):
+ def all_children(self):
return self.sources + self.depends
def current(self):
nodes[0].sources = []
nodes[1].sources = [nodes[0]]
- nodes[2].sources = [nodes[3]]
+ nodes[2].sources = []
nodes[3].sources = []
- nodes[4].sources = [nodes[5]]
+ nodes[4].sources = []
nodes[5].sources = [nodes[6]]
nodes[6].sources = [nodes[5]]
- nodes[7].sources = [nodes[2], nodes[4]]
+ nodes[7].sources = [nodes[2], nodes[4], nodes[3], nodes[5]]
nodes[8].sources = []
nodes[9].sources = [nodes[8]]
nodes[10].sources = [nodes[9]]
self.ignore = []
self.builder = None
self.use_signature = 1
- def children(self, scanner):
+ def children(self):
return filter(lambda x, i=self.ignore: x not in i, self.kids)
- def all_children(self, scanner):
+ def all_children(self):
return self.kids
def exists(self):
return 1
if not bsig is None:
return bsig
- # Collect the signatures for ALL the nodes that this
- # node depends on. Just collecting the direct
- # dependants is not good enough, because
- # the signature of a non-derived file does
- # not include the signatures of its psuedo-sources
- # (e.g. the signature for a .c file does not include
- # the signatures of the .h files that it includes).
-
- # However, we do NOT want to walk dependencies of non-
- # derived files, because calling get_signature() on the
- # derived nodes will in turn call bsig() again and do that
- # for us. Hence:
sigs = []
- def non_derived(n, parent, myself=node):
- if not n.builder or n is myself:
- return filter(lambda x, i=myself.ignore: x not in i,
- n.all_children(None))
- return []
- def get_sig(n, parent, self=self, myself=node, sigs=sigs):
- if not n is myself:
- sigs.append(self.get_signature(n))
- walker = SCons.Node.Walker(node, non_derived, eval_func=get_sig)
- child = walker.next()
- while child:
- child = walker.next()
-
+ for child in node.children():
+ sigs.append(self.get_signature(child))
if node.builder:
sigs.append(self.module.signature(node.builder_sig_adapter()))
- return self.module.collect(filter(lambda x: not x is None, sigs))
+ return self.module.collect(filter(lambda x: not x is None, sigs))
+
def csig(self, node):
"""
Generate a node's content signature, the digested signature
return csig
return self.module.signature(node)
-
+
def get_signature(self, node):
"""
Get the appropriate signature for a node.
Note that it's generally a good idea for sub-classes to call
these methods explicitly to update state, etc., rather than
roll their own interaction with Taskmaster from scratch."""
- def __init__(self, tm, targets, top, scanner = None):
+ def __init__(self, tm, targets, top, node):
self.tm = tm
self.targets = targets
self.top = top
- self.scanner = scanner
+ self.node = node
def execute(self):
+ # This methods is called from multiple threads in
+ # a parallel build, so only do thread safe stuff here.
+ # Do thread unsafe stuff in executed() or failed().
if self.targets[0].get_state() != SCons.Node.up_to_date:
self.targets[0].prepare()
self.targets[0].build()
def get_target(self):
"""Fetch the target being built or updated by this task.
"""
- return self.targets[0]
+ return self.node
def set_tstates(self, state):
"""Set all of the target nodes's states."""
things. Most importantly, this calls back to the
Taskmaster to put any node tasks waiting on this one
back on the pending list."""
+
if self.targets[0].get_state() == SCons.Node.executing:
self.set_tstates(SCons.Node.executed)
for t in self.targets:
t.store_sigs()
- parents = {}
- for p in reduce(lambda x, y: x + y.get_parents(), self.targets, []):
- parents[p] = 1
- ready = filter(lambda x, s=self.scanner:
- (x.get_state() == SCons.Node.pending
- and x.children_are_executed(s)),
- parents.keys())
- tasks = {}
- for t in map(lambda r: r.task, ready):
- tasks[t] = 1
- self.tm.pending_to_ready(tasks.keys())
+ t.built()
+
+ self.tm.executed(self.node)
def failed(self):
"""Default action when a task fails: stop the build."""
This sets failure status on the target nodes and all of
their dependent parent nodes.
"""
- nodes = {}
for t in self.targets:
def get_parents(node, parent): return node.get_parents()
- def set_nodes(node, parent, nodes=nodes): nodes[node] = 1
- walker = SCons.Node.Walker(t, get_parents, eval_func=set_nodes)
+ def set_state(node, parent): node.set_state(SCons.Node.failed)
+ walker = SCons.Node.Walker(t, get_parents, eval_func=set_state)
n = walker.next()
while n:
n = walker.next()
- pending = filter(lambda x: x.get_state() == SCons.Node.pending,
- nodes.keys())
- tasks = {}
- for t in map(lambda r: r.task, pending):
- tasks[t] = 1
- self.tm.pending_remove(tasks.keys())
+
+ self.tm.executed(self.node)
def make_ready(self):
"""Make a task ready for execution."""
if not self.tm.calc.current(t, bsig):
state = SCons.Node.executing
self.set_tstates(state)
- self.tm.add_ready(self)
-
-
class Calc:
def bsig(self, node):
"""
return 0
-
-
class Taskmaster:
"""A generic Taskmaster for handling a bunch of targets.
"""
def __init__(self, targets=[], tasker=Task, calc=Calc()):
+ self.targets = targets # top level targets
+ self.candidates = targets[:] # nodes that might be ready to be executed
+ self.candidates.reverse()
+ self.executing = [] # nodes that are currently executing
+ self.pending = [] # nodes that depend on a currently executing node
+ self.tasker = tasker
+ self.ready = None # the next task that is ready to be executed
+ self.calc = calc
+
+ def _find_next_ready_node(self):
+ """Find the next node that is ready to be built"""
+
+ if self.ready:
+ return
- def out_of_date(node, parent):
- if node.get_state():
- # The state is set, so someone has already been here
- # (finished or currently executing). Find another one.
- return []
- # Scan the file before fetching its children().
- if parent:
- scanner = parent.src_scanner_get(node.scanner_key())
- else:
- scanner = None
- return filter(lambda x: x.get_state() != SCons.Node.up_to_date,
- node.children(scanner))
+ while self.candidates:
+ node = self.candidates[-1]
+ state = node.get_state()
+
+ # Skip nodes that have already been executed:
+ if state != None and state != SCons.Node.stack:
+ self.candidates.pop()
+ continue
+
+ # keep track of which nodes are in the execution stack:
+ node.set_state(SCons.Node.stack)
- def cycle_error(node, stack):
- if node.builder:
- nodes = stack + [node]
+ children = node.children()
+
+ # detect dependency cycles:
+ def in_stack(node): return node.get_state() == SCons.Node.stack
+ cycle = filter(in_stack, children)
+ if cycle:
+ nodes = filter(in_stack, self.candidates) + cycle
nodes.reverse()
desc = "Dependency cycle: " + string.join(map(str, nodes), " -> ")
raise SCons.Errors.UserError, desc
- def eval_node(node, parent, self=self):
- if node.get_state():
- # The state is set, so someone has already been here
- # (finished or currently executing). Find another one.
- return
- if not node.builder:
- # It's a source file, we don't need to build it,
- # but mark it as "up to date" so targets won't
- # wait for it.
- node.set_state(SCons.Node.up_to_date)
- # set the signature for non-derived files
- # here so they don't get recalculated over
- # and over again:
- node.set_csig(self.calc.csig(node))
- return
- try:
- tlist = node.builder.targets(node)
- except AttributeError:
- tlist = [ node ]
- if parent:
- scanner = parent.src_scanner_get(node.scanner_key())
+ for child in children:
+ if not child.builder:
+ # set the signature for non-derived files
+ # here so they don't get recalculated over
+ # and over again:
+ child.set_csig(self.calc.csig(child))
+
+ # Add non-derived files that have not been built
+ # to the candidates list:
+ def derived(node):
+ return node.builder and node.get_state() == None
+ derived = filter(derived, children)
+ if derived:
+ derived.reverse()
+ self.candidates.extend(derived)
+ continue
+
+ # Skip nodes that are pending on a currently executing node:
+ if node.depends_on(self.executing) or node.depends_on(self.pending):
+ self.pending.append(node)
+ node.set_state(SCons.Node.pending)
+ self.candidates.pop()
+ continue
else:
- scanner = None
- task = self.tasker(self, tlist, self.walkers[0].is_done(), scanner)
- if not tlist[0].children_are_executed(scanner):
- for t in tlist:
- t.set_state(SCons.Node.pending)
- t.task = task
- self.pending = self.pending + 1
- return
- task.make_ready()
-
- #XXX In Python 2.2 we can get rid of f1, f2 and f3:
- self.walkers = map(lambda x, f1=out_of_date,
- f2=cycle_error,
- f3=eval_node:
- SCons.Node.Walker(x, f1, f2, f3),
- targets)
- self.tasker = tasker
- self.calc = calc
- self.ready = []
- self.pending = 0
-
- self._find_next_ready_node()
+ self.candidates.pop()
+ self.ready = node
+ break
def next_task(self):
"""Return the next task to be executed."""
- if self.ready:
- task = self.ready.pop()
- if not self.ready:
- self._find_next_ready_node()
- return task
- else:
- return None
+
+ self._find_next_ready_node()
- def _find_next_ready_node(self):
- """Find the next node that is ready to be built"""
- while self.walkers:
- n = self.walkers[0].next()
- if n == None:
- self.walkers.pop(0)
- continue
- if self.ready:
- return
+ node = self.ready
+
+ if node is None:
+ return None
+
+ self.executing.append(node)
+ try:
+ tlist = node.builder.targets(node)
+ except AttributeError:
+ tlist = [node]
+ task = self.tasker(self, tlist, node in self.targets, node)
+ task.make_ready()
+ self.ready = None
+
+ return task
def is_blocked(self):
+ self._find_next_ready_node()
+
return not self.ready and self.pending
def stop(self):
"""Stop the current build completely."""
- self.walkers = []
- self.pending = 0
- self.ready = []
+ self.candidates = []
+ self.ready = None
+ self.pending = []
- def add_ready(self, task):
- """Add a task to the ready queue.
- """
- self.ready.append(task)
-
- def pending_to_ready(self, tasks):
- """Move the specified tasks from the pending count
- to the 'ready' queue.
- """
- self.pending_remove(tasks)
- for t in tasks:
- t.make_ready()
-
- def pending_remove(self, tasks):
- """Remove tasks from the pending count.
+ def executed(self, node):
+ self.executing.remove(node)
- We assume that the caller has already confirmed that
- the nodes in this task are in pending state.
- """
- self.pending = self.pending - len(tasks)
+ # move the current pending nodes to the candidates list:
+ # (they may not all be ready to build, but _find_next_ready_node()
+ # will figure out which ones are really ready)
+ for node in self.pending:
+ node.set_state(None)
+ self.pending.reverse()
+ self.candidates.extend(self.pending)
+ self.pending = []
+
import SCons.Errors
-built = None
+built_text = None
executed = None
scan_called = 0
self.name = name
self.kids = kids
self.scans = scans
- self.scanned = {}
- self.src_scanners = {}
+ self.scanned = 0
+ self.scanner = None
self.builder = Node.build
self.bsig = None
self.csig = None
kid.parents.append(self)
def build(self):
- global built
- built = self.name + " built"
+ global built_text
+ built_text = self.name + " built"
+
+ def built(self):
+ global built_text
+ built_text = built_text + " really"
def prepare(self):
pass
- def children(self, scanner):
- if not self.scanned.get(scanner, None):
- self.scan(scanner)
- self.scanned[scanner] = 1
+ def children(self):
+ if not self.scanned:
+ self.scan()
+ self.scanned = 1
return self.kids
- def scan(self, scanner):
- global scan_called
- scan_called = scan_called + 1
+ def scan(self):
+ global scan_called
+ scan_called = scan_called + 1
self.kids = self.kids + self.scans
for scan in self.scans:
scan.parents.append(self)
self.scans = []
- def src_scanner_set(self, key, scanner):
- self.src_scanners[key] = scanner
-
- def src_scanner_get(self, key):
- return self.src_scanners.get(key, None)
-
def scanner_key(self):
return self.name
def store_sigs(self):
pass
- def children_are_executed(self, scanner):
- return reduce(lambda x,y: ((y.get_state() == SCons.Node.executed
- or y.get_state() == SCons.Node.up_to_date)
- and x),
- self.children(scanner),
- 1)
+
+ def depends_on(self, nodes):
+ for node in nodes:
+ if node in self.kids:
+ return 1
+ return 0
+
def __str__(self):
return self.name
class TaskmasterTestCase(unittest.TestCase):
def test_next_task(self):
- """Test fetching the next task
- """
- global built
+ """Test fetching the next task
+ """
+ global built_text
- n1 = Node("n1")
+ n1 = Node("n1")
tm = SCons.Taskmaster.Taskmaster([n1, n1])
t = tm.next_task()
- t.executed()
+ t.execute()
t = tm.next_task()
assert t == None
n2 = Node("n2")
n3 = Node("n3", [n1, n2])
- tm = SCons.Taskmaster.Taskmaster([n3])
+ tm = SCons.Taskmaster.Taskmaster([n3])
t = tm.next_task()
t.execute()
- assert built == "n1 built"
+ assert built_text == "n1 built", built_text
t.executed()
t = tm.next_task()
t.execute()
- assert built == "n2 built"
+ assert built_text == "n2 built", built_text
t.executed()
t = tm.next_task()
t.execute()
- assert built == "n3 built"
+ assert built_text == "n3 built", built_text
t.executed()
assert tm.next_task() == None
- built = "up to date: "
+ built_text = "up to date: "
top_node = n3
class MyCalc(SCons.Taskmaster.Calc):
class MyTask(SCons.Taskmaster.Task):
def execute(self):
- global built
+ global built_text
if self.targets[0].get_state() == SCons.Node.up_to_date:
if self.top:
- built = self.targets[0].name + " up-to-date top"
+ built_text = self.targets[0].name + " up-to-date top"
else:
- built = self.targets[0].name + " up-to-date"
+ built_text = self.targets[0].name + " up-to-date"
else:
self.targets[0].build()
t = tm.next_task()
t.execute()
- assert built == "n1 up-to-date"
+ assert built_text == "n1 up-to-date", built_text
t.executed()
t = tm.next_task()
t.execute()
- assert built == "n2 up-to-date"
+ assert built_text == "n2 up-to-date", built_text
t.executed()
t = tm.next_task()
t.execute()
- assert built == "n3 up-to-date top"
+ assert built_text == "n3 up-to-date top", built_text
t.executed()
- assert tm.next_task() == None
+ assert tm.next_task() == None
n1 = Node("n1")
- n2 = Node("n2")
+ n2 = Node("n2")
n3 = Node("n3", [n1, n2])
n4 = Node("n4")
n5 = Node("n5", [n3, n4])
t3.executed()
assert not tm.is_blocked()
t5 = tm.next_task()
- assert t5.get_target() == n5
+ assert t5.get_target() == n5, t5.get_target()
assert not tm.is_blocked()
assert tm.next_task() == None
t.executed()
assert tm.next_task() == None
- n1 = Node("n1")
- n2 = Node("n2")
- n3 = Node("n3", [n1, n2])
- n4 = Node("n4", [n3])
- n5 = Node("n5", [n3])
- global scan_called
- scan_called = 0
- tm = SCons.Taskmaster.Taskmaster([n4])
- t = tm.next_task()
+ n1 = Node("n1")
+ n2 = Node("n2")
+ n3 = Node("n3", [n1, n2])
+ n4 = Node("n4", [n3])
+ n5 = Node("n5", [n3])
+ global scan_called
+ scan_called = 0
+ tm = SCons.Taskmaster.Taskmaster([n4])
+ t = tm.next_task()
assert t.get_target() == n1
- t.executed()
- t = tm.next_task()
+ t.executed()
+ t = tm.next_task()
assert t.get_target() == n2
- t.executed()
- t = tm.next_task()
+ t.executed()
+ t = tm.next_task()
assert t.get_target() == n3
- t.executed()
- t = tm.next_task()
+ t.executed()
+ t = tm.next_task()
assert t.get_target() == n4
- t.executed()
- assert tm.next_task() == None
- assert scan_called == 4, scan_called
+ t.executed()
+ assert tm.next_task() == None
+ assert scan_called == 4, scan_called
- tm = SCons.Taskmaster.Taskmaster([n5])
- t = tm.next_task()
+ tm = SCons.Taskmaster.Taskmaster([n5])
+ t = tm.next_task()
assert t.get_target() == n5, t.get_target()
- t.executed()
- assert tm.next_task() == None
- assert scan_called == 5, scan_called
+ t.executed()
+ assert tm.next_task() == None
+ assert scan_called == 5, scan_called
def test_cycle_detection(self):
n1 = Node("n1")
tm = SCons.Taskmaster.Taskmaster([n3])
t = tm.next_task()
except SCons.Errors.UserError, e:
- assert str(e) == "Dependency cycle: n3 -> n1 -> n2 -> n3"
+ assert str(e) == "Dependency cycle: n3 -> n1 -> n2 -> n3", str(e)
else:
assert 0
def test_is_blocked(self):
"""Test whether a task is blocked
- Both default and overridden in a subclass.
- """
- tm = SCons.Taskmaster.Taskmaster()
- assert not tm.is_blocked()
+ Both default and overridden in a subclass.
+ """
+ tm = SCons.Taskmaster.Taskmaster()
+ assert not tm.is_blocked()
- class MyTM(SCons.Taskmaster.Taskmaster):
- def is_blocked(self):
- return 1
- tm = MyTM()
- assert tm.is_blocked() == 1
+ class MyTM(SCons.Taskmaster.Taskmaster):
+ def is_blocked(self):
+ return 1
+ tm = MyTM()
+ assert tm.is_blocked() == 1
def test_stop(self):
"""Test the stop() method
Both default and overridden in a subclass.
"""
- global built
+ global built_text
n1 = Node("n1")
n2 = Node("n2")
tm = SCons.Taskmaster.Taskmaster([n3])
t = tm.next_task()
t.execute()
- assert built == "n1 built"
+ assert built_text == "n1 built", built_text
t.executed()
+ assert built_text == "n1 built really", built_text
tm.stop()
assert tm.next_task() is None
class MyTM(SCons.Taskmaster.Taskmaster):
def stop(self):
- global built
- built = "MyTM.stop()"
+ global built_text
+ built_text = "MyTM.stop()"
SCons.Taskmaster.Taskmaster.stop(self)
n1 = Node("n1")
n2 = Node("n2")
n3 = Node("n3", [n1, n2])
- built = None
+ built_text = None
tm = MyTM([n3])
tm.next_task().execute()
- assert built == "n1 built"
+ assert built_text == "n1 built"
tm.stop()
- assert built == "MyTM.stop()"
+ assert built_text == "MyTM.stop()"
assert tm.next_task() is None
- def test_add_ready(self):
- """Test adding a task to the ready queue"""
- class MyTask:
- def __init__(self, tm, tlist, top, scanner):
- pass
- def make_ready(self):
- pass
- n1 = Node("n1")
- tm = SCons.Taskmaster.Taskmaster([n1], tasker = MyTask)
- task = MyTask(tm, [], 0, None)
- tm.add_ready(task)
- assert tm.ready == [ task ], tm.ready
-
- def test_pending_to_ready(self):
- pass
-
- def test_pending_remove(self):
+ def test_executed(self):
pass
if __name__ == "__main__":
suite = unittest.makeSuite(TaskmasterTestCase, 'test_')
if not unittest.TextTestRunner().run(suite).wasSuccessful():
- sys.exit(1)
+ sys.exit(1)
include_re = re.compile(r'^include\s+(\S+)$', re.M)
-def kfile_scan(node, env, arg):
+def kfile_scan(node, env, target, arg):
contents = node.get_contents()
includes = include_re.findall(contents)
return includes
bar_in = File('bar.in')
env.Command('bar', bar_in, '%s build.py $SOURCES $TARGET')
-bar_in.scanner_set(kscan)
+bar_in.source_scanner = kscan
""" % (python, python))
test.write('foo.k',
test.fail_test(test.read('bar') != "yyy 2\nbar.in 1 line 2\nbar.in 1 line 3\nzzz 2\n")
+test.run(arguments = 'foo', stdout='scons: "foo" is up to date.\n')
+
test.pass_test()
void
f1(void)
{
- printf("f1.c\n");
-}
+ printf("f1.c\n");
+}
""")
-test.run(arguments = ".", stdout = "", stderr=r"""
+test.run(arguments = ".", stderr=r"""
SCons error: Dependency cycle: .*foo1.* -> .*foo3.* -> .*foo2.* -> .*foo1.* -> \.
.*
""", status=2)
+test.fail_test(test.stdout() == "")
+
test.pass_test()
+-%s
+-foo%s
| +-foo.c
- | +-foo.h
- | +-bar.h
+ | +-foo.h
+ | +-bar.h
+-bar%s
+-bar.c
- +-bar.h
- +-foo.h
+ +-bar.h
+ +-foo.h
""" % (foo, obj,obj)
test.fail_test(string.find(test.stdout(), tree) == -1)
test.run(arguments = "--debug=tree " + foo)
test.fail_test(string.find(test.stdout(), tree) == -1)
+tree = """scons: \".\" is up to date.
+
++-.
+ +-SConstruct
+ +-bar.c
+ +-bar.h
+ +-bar%(obj)s
+ | +-bar.c
+ | +-bar.h
+ | +-foo.h
+ +-%(foo)s
+ | +-foo%(obj)s
+ | | +-foo.c
+ | | +-foo.h
+ | | +-bar.h
+ | +-bar%(obj)s
+ | +-bar.c
+ | +-bar.h
+ | +-foo.h
+ +-foo.c
+ +-foo.h
+ +-foo%(obj)s
+ +-foo.c
+ +-foo.h
+ +-bar.h
+""" % globals()
+test.run(arguments = "--debug=tree .")
+test.fail_test(string.find(test.stdout(), tree) != 0)
+
test.run(arguments = "--debug=pdb", stdin = "n\ns\nq\n")
test.fail_test(string.find(test.stdout(), "(Pdb)") == -1)
test.fail_test(string.find(test.stdout(), "scons") == -1)
projects / scons.git / commitdiff