def set_bsig(self, bsig):
"""An alias has no signature."""
- pass
+ self.bsig = None
def set_csig(self, csig):
"""An alias has no signature."""
- pass
+ self.csig = None
- def current(self):
+ def current(self, calc):
"""If all of our children were up-to-date, then this
Alias was up-to-date, too."""
+ # Allow the children to calculate their signatures.
+ calc.bsig(self)
state = 0
for kid in self.children(None):
s = kid.get_state()
pass
def is_under(self, dir):
- # Make Alias nodes get built regardless of
- # what directory scons was run from. Alias nodes
- # are outside the filesystem:
- return 1
+ # Make Alias nodes get built regardless of
+ # what directory scons was run from. Alias nodes
+ # are outside the filesystem:
+ return 1
default_ans = AliasNameSpace()
self.path_ = self.path
self.abspath_ = self.abspath
self.dir = directory
- self.use_signature = 1
self.__doSrcpath(self.duplicate)
self.srcpath_ = self.srcpath
self.cwd = None # will hold the SConscript directory for target nodes
parents.append(self.dir)
return parents
- def current(self):
+ def current(self, calc):
"""If the underlying path doesn't exist, we know the node is
not current without even checking the signature, so return 0.
Otherwise, return None to indicate that signature calculation
should proceed as normal to find out if the node is current."""
+ bsig = calc.bsig(self)
if not self.exists():
return 0
- return None
+ return calc.current(self, bsig)
def is_under(self, dir):
if self is dir:
self.entries = {}
self.entries['.'] = self
self.entries['..'] = self.dir
- self.use_signature = None
self.builder = 1
self._sconsign = None
"""A null "builder" for directories."""
pass
+ def calc_signature(self, calc):
+ """A directory has no signature."""
+ return None
+
def set_bsig(self, bsig):
"""A directory has no signature."""
- pass
+ bsig = None
def set_csig(self, csig):
"""A directory has no signature."""
- pass
+ csig = None
def get_contents(self):
"""Return a fixed "contents" value of a directory."""
return ''
- def current(self):
+ def current(self, calc):
"""If all of our children were up-to-date, then this
directory was up-to-date, too."""
state = 0
if not hasattr(self, '_rfile'):
self._rfile = self
if not os.path.isabs(self.path) and not os.path.isfile(self.path):
- def file_node(path, fs = self.fs):
- if os.path.isfile(path):
- return fs.File(path)
- return None
+ def file_node(path, fs = self.fs):
+ if os.path.isfile(path):
+ return fs.File(path)
+ return None
n = self.fs.Rsearch(self.path, file_node)
if n:
self._rfile = n
self.target_scanner = None # explicit scanner from this node's Builder
self.env = None
self.state = None
- self.bsig = None
- self.csig = None
- self.use_signature = 1
self.precious = None
self.found_includes = {}
self.includes = None
def get_parents(node, parent): return node.get_parents()
def clear_cache(node, parent):
node.implicit = None
- node.bsig = None
+ node.del_bsig()
w = Walker(self, get_parents, ignore_cycle, clear_cache)
while w.next(): pass
# clear out the content signature, since the contents of this
# node were presumably just changed:
- self.csig = None
+ self.del_csig()
def depends_on(self, nodes):
"""Does this node depend on any of 'nodes'?"""
# we need to recalculate the implicit deps,
# and the bsig:
self.implicit = []
- self.bsig = None
+ self.del_bsig()
for child in self.children(scan=0):
self._add_child(self.implicit,
return
self.env = env
+ def calc_signature(self, calc):
+ """
+ Select and calculate the appropriate build signature for a node.
+
+ self - the node
+ calc - the signature calculation module
+ returns - the signature
+
+ This method does not store the signature in the node or
+ in the .sconsign file.
+ """
+
+ if self.builder:
+ if SCons.Sig.build_signature:
+ if not hasattr(self, 'bsig'):
+ self.set_bsig(calc.bsig(self))
+ return self.get_bsig()
+ else:
+ if not hasattr(self, 'csig'):
+ self.set_csig(calc.csig(self))
+ return self.get_csig()
+ elif not self.exists():
+ return None
+ else:
+ if not hasattr(self, 'csig'):
+ self.set_csig(calc.csig(self))
+ return self.get_csig()
+
def get_bsig(self):
"""Get the node's build signature (based on the signatures
of its dependency files and build information)."""
+ if not hasattr(self, 'bsig'):
+ return None
return self.bsig
def set_bsig(self, bsig):
.sconsign file or equivalent)."""
pass
+ def del_bsig(self):
+ """Delete the bsig from this node."""
+ if hasattr(self, 'bsig'):
+ delattr(self, 'bsig')
+
def get_csig(self):
"""Get the signature of the node's content."""
+ if not hasattr(self, 'csig'):
+ return None
return self.csig
def set_csig(self, csig):
.sconsign file or equivalent)."""
pass
+ def del_csig(self):
+ """Delete the csig from this node."""
+ if hasattr(self, 'csig'):
+ delattr(self, 'csig')
+
def get_prevsiginfo(self):
"""Fetch the previous signature information from the
.sconsign entry."""
return 0
return None
+ def calc_signature(self, calc):
+ if self.builder:
+ return calc.bsig(self)
+ else:
+ return calc.csig(self)
+
def set_bsig(self, bsig):
self.bsig = bsig
return nodes
def current(calc, node):
- s = calc.get_signature(node)
- return calc.current(node, s)
+ return calc.current(node, node.calc_signature(calc))
def write(calc, nodes):
for node in nodes:
self.test_built()
self.test_modify()
self.test_modify_same_time()
- self.test_delete()
- self.test_cache()
def test_initial(self):
self.failUnless(current(calc, node),
"all of the nodes should be current")
- def test_delete(self):
-
- nodes = create_nodes(self.files)
-
- calc = SCons.Sig.Calculator(self.module)
-
- write(calc, nodes)
-
- #simulate the deletion of some files
- self.files[1].modify(None, 0)
- self.files[7].modify(None, 0)
- self.files[9].modify(None, 0)
-
- self.failUnless(current(calc, nodes[0]))
- self.failUnless(not current(calc, nodes[1]), "deleted")
- self.failUnless(current(calc, nodes[2]))
- self.failUnless(current(calc, nodes[3]))
- self.failUnless(current(calc, nodes[4]))
- self.failUnless(current(calc, nodes[5]))
- self.failUnless(current(calc, nodes[6]))
- self.failUnless(not current(calc, nodes[7]), "deleted")
- self.failUnless(current(calc, nodes[8]))
- self.failUnless(not current(calc, nodes[9]), "deleted")
- self.failUnless(current(calc, nodes[10]),
- "current even though its source was deleted")
-
- def test_cache(self):
- """Test that signatures are cached properly."""
- nodes = create_nodes(self.files)
-
- calc = SCons.Sig.Calculator(self.module)
- nodes[0].set_csig(1)
- nodes[1].set_bsig(1)
- assert calc.csig(nodes[0]) == 1, calc.csig(nodes[0])
- assert calc.bsig(nodes[1]) == 1, calc.bsig(nodes[1])
-
class MD5TestCase(unittest.TestCase, SigTestBase):
"""Test MD5 signatures"""
return self.bsig
def set_bsig(self, bsig):
self.bsig = bsig
- def store_sigs(self):
- pass
def get_csig(self):
return self.csig
+ def set_csig(self, csig):
+ self.csig = csig
+ def store_csig(self):
+ pass
+ def store_timestamp(self):
+ pass
def get_prevsiginfo(self):
return 0, self.bsig, self.csig
def get_stored_implicit(self):
self.nodeclass = MyNode
self.test_Calc___init__()
self.test_Calc_bsig()
- self.test_Calc_get_signature()
self.test_Calc_current()
def test_Calc___init__(self):
assert self.calc.csig(n) == 12
- def test_Calc_get_signature(self):
- class NE(self.nodeclass):
- def exists(self):
- return 0
- def cached_exists(self):
- return 0
- def has_signature(self):
- return None
- class NN(self.nodeclass):
- def exists(self):
- return 1
- def has_signature(self):
- return None
-
- n1 = self.nodeclass('n1', 11, 12)
- n1.use_signature = 0
- assert self.calc.get_signature(n1) is None
-
- n2 = self.nodeclass('n2', 22, 23)
- assert self.calc.get_signature(n2) == 23
-
- n3 = self.nodeclass('n3', 33, 34)
- n4 = self.nodeclass('n4', None, None)
- n4.builder = 1
- n4.kids = [n2, n3]
- assert self.calc.get_signature(n4) == 390
-
- n5 = NE('n5', 55, 56)
- assert self.calc.get_signature(n5) is None
-
- n6 = NN('n6', 66, 67)
- assert self.calc.get_signature(n6) == 67
-
def test_Calc_current(self):
- class N0(self.nodeclass):
- def current(self):
- return 0
- class N1(self.nodeclass):
- def current(self):
- return 1
class NN(self.nodeclass):
def current(self):
return None
- n0 = N0('n0', 11, 12)
- assert not self.calc.current(n0, 10)
- assert not self.calc.current(n0, 11)
-
- n1 = N1('n1', 22, 23)
- assert self.calc.current(n1, 20)
- assert self.calc.current(n1, 22)
-
nn = NN('nn', 33, 34)
assert not self.calc.current(nn, 30)
assert self.calc.current(nn, 33)
already built and updated by someone else, if that's
what's wanted.
"""
- if not node.use_signature:
- return None
-
- bsig = node.get_bsig()
- if not bsig is None:
- return bsig
-
- sigs = map(self.get_signature, node.children())
+ sigs = map(lambda n, c=self: n.calc_signature(c), node.children())
if node.builder:
sigs.append(self.module.signature(node.builder_sig_adapter()))
node - the node
returns - the content signature
"""
- if not node.use_signature:
- return None
-
- csig = node.get_csig()
- if not csig is None:
- return csig
-
if self.max_drift >= 0:
info = node.get_prevsiginfo()
else:
return csig
- def get_signature(self, node):
- """
- Get the appropriate build signature for a node.
-
- node - the node
- returns - the signature or None if the signature could not
- be computed.
-
- This method does not store the signature in the node or
- in the .sconsign file.
- """
-
- if not node.use_signature:
- # This node type doesn't use a signature (e.g. a
- # directory) so bail right away.
- return None
- elif node.builder:
- if build_signature:
- return self.bsig(node)
- else:
- return self.csig(node)
- elif not node.exists():
- return None
- else:
- return self.csig(node)
-
def current(self, node, newsig):
"""
Check if a signature is up to date with respect to a node.
returns - 1 if the file is current with the specified signature,
0 if it isn't
"""
-
- c = node.current()
- if not c is None:
- # The node itself has told us whether or not it's
- # current without checking the signature. The
- # canonical uses here are a "0" return for a file
- # that doesn't exist, or a directory.
- return c
-
oldtime, oldbsig, oldcsig = node.get_prevsiginfo()
if not node.builder and node.get_timestamp() == oldtime:
"""Make a task ready for execution."""
state = SCons.Node.up_to_date
for t in self.targets:
- bsig = self.tm.calc.bsig(t)
- if not self.tm.calc.current(t, bsig):
+ if not t.current(self.tm.calc):
state = SCons.Node.executing
for t in self.targets:
if state == SCons.Node.executing:
def store_bsig(self):
pass
-
+
+ def current(self, calc):
+ return calc.current(self, calc.bsig(self))
def depends_on(self, nodes):
for node in nodes:
projects / scons.git / commitdiff