Update to SCons 1.2.0.

third_party/scons/scons-local/SCons/Node/FS.py

 """scons.Node.FS
 
 File system nodes.
 
 These Nodes represent the canonical external objects that people think
 of when they think of building software: files and directories.
 
 This holds a "default_fs" variable that should be initialized with an FS
 that can be used by scripts or modules looking for the canonical default.
 
@@ skipping 15 matching lines @@
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-__revision__ = "src/engine/SCons/Node/FS.py 3603 2008/10/10 05:46:45 scons"
+__revision__ = "src/engine/SCons/Node/FS.py 3842 2008/12/20 22:59:52 scons"
 
 import fnmatch
 from itertools import izip
 import os
 import os.path
 import re
 import shutil
 import stat
 import string
 import sys
 import time
 import cStringIO
 
 import SCons.Action
 from SCons.Debug import logInstanceCreation
 import SCons.Errors
 import SCons.Memoize
 import SCons.Node
 import SCons.Node.Alias
 import SCons.Subst
 import SCons.Util
 import SCons.Warnings
 
 from SCons.Debug import Trace
 
 do_store_info = True
 
+
+class EntryProxyAttributeError(AttributeError):
+    """
+    An AttributeError subclass for recording and displaying the name
+    of the underlying Entry involved in an AttributeError exception.
+    """
+    def __init__(self, entry_proxy, attribute):
+        AttributeError.__init__(self)
+        self.entry_proxy = entry_proxy
+        self.attribute = attribute
+    def __str__(self):
+        entry = self.entry_proxy.get()
+        fmt = "%s instance %s has no attribute %s"
+        return fmt % (entry.__class__.__name__,
+                      repr(entry.name),
+                      repr(self.attribute))
+
 # The max_drift value:  by default, use a cached signature value for
 # any file that's been untouched for more than two days.
 default_max_drift = 2*24*60*60
 
 #
 # We stringify these file system Nodes a lot.  Turning a file system Node
 # into a string is non-trivial, because the final string representation
 # can depend on a lot of factors:  whether it's a derived target or not,
 # whether it's linked to a repository or source directory, and whether
 # there's duplication going on.  The normal technique for optimizing
@@ skipping 144 matching lines @@
         except (IOError, OSError):
             # An OSError indicates something happened like a permissions
             # problem or an attempt to symlink across file-system
             # boundaries.  An IOError indicates something like the file
             # not existing.  In either case, keeping trying additional
             # functions in the list and only raise an error if the last
             # one failed.
             if func == Link_Funcs[-1]:
                 # exception of the last link method (copy) are fatal
                 raise
-            else:
-                pass
     return 0
 
 Link = SCons.Action.Action(LinkFunc, None)
 def LocalString(target, source, env):
     return 'Local copy of %s from %s' % (target[0], source[0])
 
 LocalCopy = SCons.Action.Action(LinkFunc, LocalString)
 
 def UnlinkFunc(target, source, env):
     t = target[0]
@@ skipping 238 matching lines @@
                        }
 
     def __getattr__(self, name):
         # This is how we implement the "special" attributes
         # such as base, posix, srcdir, etc.
         try:
             attr_function = self.dictSpecialAttrs[name]
         except KeyError:
             try:
                 attr = SCons.Util.Proxy.__getattr__(self, name)
-            except AttributeError:
-                entry = self.get()
-                classname = string.split(str(entry.__class__), '.')[-1]
-                if classname[-2:] == "'>":
-                    # new-style classes report their name as:
-                    #   "<class 'something'>"
-                    # instead of the classic classes:
-                    #   "something"
-                    classname = classname[:-2]
-                raise AttributeError, "%s instance '%s' has no attribute '%s'" % (classname, entry.name, name)
+            except AttributeError, e:
+                # Raise our own AttributeError subclass with an
+                # overridden __str__() method that identifies the
+                # name of the entry that caused the exception.
+                raise EntryProxyAttributeError(self, name)
             return attr
         else:
             return attr_function(self)
 
 class Base(SCons.Node.Node):
     """A generic class for file system entries.  This class is for
     when we don't know yet whether the entry being looked up is a file
     or a directory.  Instances of this class can morph into either
     Dir or File objects by a later, more precise lookup.
 
@@ skipping 77 matching lines @@
             pass
         result = self._get_str()
         self._memo['_save_str'] = result
         return result
 
     def _get_str(self):
         global Save_Strings
         if self.duplicate or self.is_derived():
             return self.get_path()
         srcnode = self.srcnode()
-        if srcnode.stat() is None and not self.stat() is None:
+        if srcnode.stat() is None and self.stat() is not None:
             result = self.get_path()
         else:
             result = srcnode.get_path()
         if not Save_Strings:
             # We're not at the point where we're saving the string string
             # representations of FS Nodes (because we haven't finished
             # reading the SConscript files and need to have str() return
             # things relative to them).  That also means we can't yet
             # cache values returned (or not returned) by stat(), since
             # Python code in the SConscript files might still create
             # or otherwise affect the on-disk file.  So get rid of the
             # values that the underlying stat() method saved.
             try: del self._memo['stat']
             except KeyError: pass
-            if not self is srcnode:
+            if self is not srcnode:
                 try: del srcnode._memo['stat']
                 except KeyError: pass
         return result
 
     rstr = __str__
 
     memoizer_counters.append(SCons.Memoize.CountValue('stat'))
 
     def stat(self):
         try: return self._memo['stat']
         except KeyError: pass
         try: result = self.fs.stat(self.abspath)
         except os.error: result = None
         self._memo['stat'] = result
         return result
 
     def exists(self):
-        return not self.stat() is None
+        return self.stat() is not None
 
     def rexists(self):
         return self.rfile().exists()
 
     def getmtime(self):
         st = self.stat()
         if st: return st[stat.ST_MTIME]
         else: return None
 
     def getsize(self):
         st = self.stat()
         if st: return st[stat.ST_SIZE]
         else: return None
 
     def isdir(self):
         st = self.stat()
-        return not st is None and stat.S_ISDIR(st[stat.ST_MODE])
+        return st is not None and stat.S_ISDIR(st[stat.ST_MODE])
 
     def isfile(self):
         st = self.stat()
-        return not st is None and stat.S_ISREG(st[stat.ST_MODE])
+        return st is not None and stat.S_ISREG(st[stat.ST_MODE])
 
     if hasattr(os, 'symlink'):
         def islink(self):
             try: st = self.fs.lstat(self.abspath)
             except os.error: return 0
             return stat.S_ISLNK(st[stat.ST_MODE])
     else:
         def islink(self):
             return 0                    # no symlinks
 
@@ skipping 219 matching lines @@
             # string so calls to get_contents() in emitters and the
             # like (e.g. in qt.py) don't have to disambiguate by hand
             # or catch the exception.
             return ''
         else:
             return self.get_contents()
 
     def must_be_same(self, klass):
         """Called to make sure a Node is a Dir.  Since we're an
         Entry, we can morph into one."""
-        if not self.__class__ is klass:
+        if self.__class__ is not klass:
             self.__class__ = klass
             self._morph()
             self.clear()
 
     # The following methods can get called before the Taskmaster has
     # had a chance to call disambiguate() directly to see if this Entry
     # should really be a Dir or a File.  We therefore use these to call
     # disambiguate() transparently (from our caller's point of view).
     #
     # Right now, this minimal set of methods has been derived by just
     # looking at some of the methods that will obviously be called early
     # in any of the various Taskmasters' calling sequences, and then
     # empirically figuring out which additional methods are necessary
     # to make various tests pass.
 
     def exists(self):
         """Return if the Entry exists.  Check the file system to see
         what we should turn into first.  Assume a file if there's no
         directory."""
         return self.disambiguate().exists()
 
     def rel_path(self, other):
         d = self.disambiguate()
-        if d.__class__ == Entry:
+        if d.__class__ is Entry:
             raise "rel_path() could not disambiguate File/Dir"
         return d.rel_path(other)
 
     def new_ninfo(self):
         return self.disambiguate().new_ninfo()
 
     def changed_since_last_build(self, target, prev_ni):
         return self.disambiguate().changed_since_last_build(target, prev_ni)
 
     def _glob1(self, pattern, ondisk=True, source=False, strings=False):
@@ skipping 134 matching lines @@
     def getcwd(self):
         return self._cwd
 
     def chdir(self, dir, change_os_dir=0):
         """Change the current working directory for lookups.
         If change_os_dir is true, we will also change the "real" cwd
         to match.
         """
         curr=self._cwd
         try:
-            if not dir is None:
+            if dir is not None:
                 self._cwd = dir
                 if change_os_dir:
                     os.chdir(dir.abspath)
         except OSError:
             self._cwd = curr
             raise
 
     def get_root(self, drive):
         """
         Returns the root directory for the specified drive, creating
@@ skipping 85 matching lines @@
         else:
             if not directory:
                 directory = self._cwd
             root = directory.root
 
         if os.sep != '/':
             p = string.replace(p, os.sep, '/')
         return root._lookup_abs(p, fsclass, create)
 
     def Entry(self, name, directory = None, create = 1):
-        """Lookup or create a generic Entry node with the specified name.
+        """Look up or create a generic Entry node with the specified name.
         If the name is a relative path (begins with ./, ../, or a file
         name), then it is looked up relative to the supplied directory
         node, or to the top level directory of the FS (supplied at
         construction time) if no directory is supplied.
         """
         return self._lookup(name, directory, Entry, create)
 
     def File(self, name, directory = None, create = 1):
-        """Lookup or create a File node with the specified name.  If
+        """Look up or create a File node with the specified name.  If
         the name is a relative path (begins with ./, ../, or a file name),
         then it is looked up relative to the supplied directory node,
         or to the top level directory of the FS (supplied at construction
         time) if no directory is supplied.
 
         This method will raise TypeError if a directory is found at the
         specified path.
         """
         return self._lookup(name, directory, File, create)
 
     def Dir(self, name, directory = None, create = True):
-        """Lookup or create a Dir node with the specified name.  If
+        """Look up or create a Dir node with the specified name.  If
         the name is a relative path (begins with ./, ../, or a file name),
         then it is looked up relative to the supplied directory node,
         or to the top level directory of the FS (supplied at construction
         time) if no directory is supplied.
 
         This method will raise TypeError if a normal file is found at the
         specified path.
         """
         return self._lookup(name, directory, Dir, create)
 
@@ skipping 135 matching lines @@
         for node in self.entries.values():
             if node != self.dir:
                 if node != self and isinstance(node, Dir):
                     node.__clearRepositoryCache(duplicate)
                 else:
                     node.clear()
                     try:
                         del node._srcreps
                     except AttributeError:
                         pass
-                    if duplicate != None:
+                    if duplicate is not None:
                         node.duplicate=duplicate
 
     def __resetDuplicate(self, node):
         if node != self:
             node.duplicate = node.get_dir().duplicate
 
     def Entry(self, name):
         """
         Looks up or creates an entry node named 'name' relative to
         this directory.
         """
         return self.fs.Entry(name, self)
 
     def Dir(self, name, create=True):
         """
         Looks up or creates a directory node named 'name' relative to
         this directory.
         """
-        dir = self.fs.Dir(name, self, create)
-        return dir
+        return self.fs.Dir(name, self, create)
 
     def File(self, name):
         """
         Looks up or creates a file node named 'name' relative to
         this directory.
         """
         return self.fs.File(name, self)
 
     def _lookup_rel(self, name, klass, create=1):
         """
@@ skipping 62 matching lines @@
 
     def _rel_path_key(self, other):
         return str(other)
 
     memoizer_counters.append(SCons.Memoize.CountDict('rel_path', _rel_path_key))
 
     def rel_path(self, other):
         """Return a path to "other" relative to this directory.
         """
 
-        # This complicated and expensive method, which constructs relative
-        # paths between arbitrary Node.FS objects, is no longer used
-        # by SCons itself.  It was introduced to store dependency paths
-        # in .sconsign files relative to the target, but that ended up
-        # being significantly inefficient.
+        # This complicated and expensive method, which constructs relative
+        # paths between arbitrary Node.FS objects, is no longer used
+        # by SCons itself.  It was introduced to store dependency paths
+        # in .sconsign files relative to the target, but that ended up
+        # being significantly inefficient.
         #
-        # We're continuing to support the method because some SConstruct
-        # files out there started using it when it was available, and
-        # we're all about backwards compatibility..
+        # We're continuing to support the method because some SConstruct
+        # files out there started using it when it was available, and
+        # we're all about backwards compatibility..
 
         try:
             memo_dict = self._memo['rel_path']
         except KeyError:
             memo_dict = {}
             self._memo['rel_path'] = memo_dict
         else:
             try:
                 return memo_dict[other]
             except KeyError:
                 pass
 
         if self is other:
-
             result = '.'
 
         elif not other in self.path_elements:
-
             try:
                 other_dir = other.get_dir()
             except AttributeError:
                 result = str(other)
             else:
                 if other_dir is None:
                     result = other.name
                 else:
                     dir_rel_path = self.rel_path(other_dir)
                     if dir_rel_path == '.':
                         result = other.name
                     else:
                         result = dir_rel_path + os.sep + other.name
-
         else:
-
             i = self.path_elements.index(other) + 1
 
             path_elems = ['..'] * (len(self.path_elements) - i) \
                          + map(lambda n: n.name, other.path_elements[i:])
              
             result = string.join(path_elems, os.sep)
 
         memo_dict[other] = result
 
         return result
@@ skipping 30 matching lines @@
     #
     # Taskmaster interface subsystem
     #
 
     def prepare(self):
         pass
 
     def build(self, **kw):
         """A null "builder" for directories."""
         global MkdirBuilder
-        if not self.builder is MkdirBuilder:
+        if self.builder is not MkdirBuilder:
             apply(SCons.Node.Node.build, [self,], kw)
 
     #
     #
     #
 
     def _create(self):
         """Create this directory, silently and without worrying about
         whether the builder is the default or not."""
         listDirs = []
         parent = self
         while parent:
             if parent.exists():
                 break
             listDirs.append(parent)
-            p = parent.up()
-            if p is None:
-                raise SCons.Errors.StopError, parent.path
-            parent = p
+            parent = parent.up()
+        else:
+            raise SCons.Errors.StopError, parent.path
         listDirs.reverse()
         for dirnode in listDirs:
             try:
                 # Don't call dirnode.build(), call the base Node method
                 # directly because we definitely *must* create this
                 # directory.  The dirnode.build() method will suppress
                 # the build if it's the default builder.
                 SCons.Node.Node.build(dirnode)
                 dirnode.get_executor().nullify()
                 # The build() action may or may not have actually
                 # created the directory, depending on whether the -n
                 # option was used or not.  Delete the _exists and
                 # _rexists attributes so they can be reevaluated.
                 dirnode.clear()
             except OSError:
                 pass
 
     def multiple_side_effect_has_builder(self):
         global MkdirBuilder
-        return not self.builder is MkdirBuilder and self.has_builder()
+        return self.builder is not MkdirBuilder and self.has_builder()
 
     def alter_targets(self):
         """Return any corresponding targets in a variant directory.
         """
         return self.fs.variant_dir_target_climb(self, self, [])
 
     def scanner_key(self):
         """A directory does not get scanned."""
         return None
 
@@ skipping 18 matching lines @@
         return SCons.Util.MD5signature(contents)
 
     def do_duplicate(self, src):
         pass
 
     changed_since_last_build = SCons.Node.Node.state_has_changed
 
     def is_up_to_date(self):
         """If any child is not up-to-date, then this directory isn't,
         either."""
-        if not self.builder is MkdirBuilder and not self.exists():
+        if self.builder is not MkdirBuilder and not self.exists():
             return 0
         up_to_date = SCons.Node.up_to_date
         for kid in self.children():
             if kid.get_state() > up_to_date:
                 return 0
         return 1
 
     def rdir(self):
         if not self.exists():
             norm_name = _my_normcase(self.name)
@@ skipping 152 matching lines @@
         return node
 
     def file_on_disk(self, name):
         if self.entry_exists_on_disk(name) or \
            diskcheck_rcs(self, name) or \
            diskcheck_sccs(self, name):
             try: return self.File(name)
             except TypeError: pass
         node = self.srcdir_duplicate(name)
         if isinstance(node, Dir):
-            node = None
+            return None
         return node
 
     def walk(self, func, arg):
         """
         Walk this directory tree by calling the specified function
         for each directory in the tree.
 
         This behaves like the os.path.walk() function, but for in-memory
         Node.FS.Dir objects.  The function takes the same arguments as
         the functions passed to os.path.walk():
@@ skipping 72 matching lines @@
         This searches any repositories and source directories for
         corresponding entries and returns a Node (or string) relative
         to the current directory if an entry is found anywhere.
 
         TODO: handle pattern with no wildcard
         """
         search_dir_list = self.get_all_rdirs()
         for srcdir in self.srcdir_list():
             search_dir_list.extend(srcdir.get_all_rdirs())
 
+        selfEntry = self.Entry
         names = []
         for dir in search_dir_list:
             # We use the .name attribute from the Node because the keys of
             # the dir.entries dictionary are normalized (that is, all upper
             # case) on case-insensitive systems like Windows.
             #node_names = [ v.name for k, v in dir.entries.items() if k not in ('.', '..') ]
             entry_names = filter(lambda n: n not in ('.', '..'), dir.entries.keys())
             node_names = map(lambda n, e=dir.entries: e[n].name, entry_names)
             names.extend(node_names)
             if not strings:
                 # Make sure the working directory (self) actually has
                 # entries for all Nodes in repositories or variant dirs.
-                map(self.Entry, node_names)
+                map(selfEntry, node_names)
             if ondisk:
                 try:
                     disk_names = os.listdir(dir.abspath)
                 except os.error:
-                    pass
-                else:
-                    names.extend(disk_names)
-                    if not strings:
-                        # We're going to return corresponding Nodes in
-                        # the local directory, so we need to make sure
-                        # those Nodes exist.  We only want to create
-                        # Nodes for the entries that will match the
-                        # specified pattern, though, which means we
-                        # need to filter the list here, even though
-                        # the overall list will also be filtered later,
-                        # after we exit this loop.
-                        if pattern[0] != '.':
-                            #disk_names = [ d for d in disk_names if d[0] != '.' ]
-                            disk_names = filter(lambda x: x[0] != '.', disk_names)
-                        disk_names = fnmatch.filter(disk_names, pattern)
-                        rep_nodes = map(dir.Entry, disk_names)
-                        #rep_nodes = [ n.disambiguate() for n in rep_nodes ]
-                        rep_nodes = map(lambda n: n.disambiguate(), rep_nodes)
-                        for node, name in izip(rep_nodes, disk_names):
-                            n = self.Entry(name)
-                            if n.__class__ != node.__class__:
-                                n.__class__ = node.__class__
-                                n._morph()
+                    continue
+                names.extend(disk_names)
+                if not strings:
+                    # We're going to return corresponding Nodes in
+                    # the local directory, so we need to make sure
+                    # those Nodes exist.  We only want to create
+                    # Nodes for the entries that will match the
+                    # specified pattern, though, which means we
+                    # need to filter the list here, even though
+                    # the overall list will also be filtered later,
+                    # after we exit this loop.
+                    if pattern[0] != '.':
+                        #disk_names = [ d for d in disk_names if d[0] != '.' ]
+                        disk_names = filter(lambda x: x[0] != '.', disk_names)
+                    disk_names = fnmatch.filter(disk_names, pattern)
+                    dirEntry = dir.Entry
+                    for name in disk_names:
+                        # Add './' before disk filename so that '#' at
+                        # beginning of filename isn't interpreted.
+                        name = './' + name
+                        node = dirEntry(name).disambiguate()
+                        n = selfEntry(name)
+                        if n.__class__ != node.__class__:
+                            n.__class__ = node.__class__
+                            n._morph()
 
         names = set(names)
         if pattern[0] != '.':
             #names = [ n for n in names if n[0] != '.' ]
             names = filter(lambda x: x[0] != '.', names)
         names = fnmatch.filter(names, pattern)
 
         if strings:
             return names
 
@@ skipping 188 matching lines @@
         attrs = [
             ('bsources', 'bsourcesigs'),
             ('bdepends', 'bdependsigs'),
             ('bimplicit', 'bimplicitsigs'),
         ]
         for (nattr, sattr) in attrs:
             try:
                 strings = getattr(self, nattr)
                 nodeinfos = getattr(self, sattr)
             except AttributeError:
-                pass
-            else:
-                nodes = []
-                for s, ni in izip(strings, nodeinfos):
-                    if not isinstance(s, SCons.Node.Node):
-                        s = ni.str_to_node(s)
-                    nodes.append(s)
-                setattr(self, nattr, nodes)
+                continue
+            nodes = []
+            for s, ni in izip(strings, nodeinfos):
+                if not isinstance(s, SCons.Node.Node):
+                    s = ni.str_to_node(s)
+                nodes.append(s)
+            setattr(self, nattr, nodes)
     def format(self, names=0):
         result = []
         bkids = self.bsources + self.bdepends + self.bimplicit
         bkidsigs = self.bsourcesigs + self.bdependsigs + self.bimplicitsigs
         for bkid, bkidsig in izip(bkids, bkidsigs):
             result.append(str(bkid) + ': ' +
                           string.join(bkidsig.format(names=names), ' '))
         result.append('%s [%s]' % (self.bactsig, self.bact))
         return string.join(result, '\n')
 
@@ skipping 12 matching lines @@
         diskcheck_match(self, self.isdir,
                         "Directory %s found where file expected.")
 
     def __init__(self, name, directory, fs):
         if __debug__: logInstanceCreation(self, 'Node.FS.File')
         Base.__init__(self, name, directory, fs)
         self._morph()
 
     def Entry(self, name):
         """Create an entry node named 'name' relative to
-        the SConscript directory of this file."""
-        cwd = self.cwd or self.fs._cwd
-        return cwd.Entry(name)
+        the directory of this file."""
+        return self.dir.Entry(name)
 
     def Dir(self, name, create=True):
         """Create a directory node named 'name' relative to
-        the SConscript directory of this file."""
-        cwd = self.cwd or self.fs._cwd
-        return cwd.Dir(name, create)
+        the directory of this file."""
+        return self.dir.Dir(name, create=create)
 
     def Dirs(self, pathlist):
         """Create a list of directories relative to the SConscript
         directory of this file."""
+        # TODO(1.5)
+        # return [self.Dir(p) for p in pathlist]
         return map(lambda p, s=self: s.Dir(p), pathlist)
 
     def File(self, name):
         """Create a file node named 'name' relative to
-        the SConscript directory of this file."""
-        cwd = self.cwd or self.fs._cwd
-        return cwd.File(name)
+        the directory of this file."""
+        return self.dir.File(name)
 
     #def generate_build_dict(self):
     #    """Return an appropriate dictionary of values for building
     #    this File."""
     #    return {'Dir' : self.Dir,
     #            'File' : self.File,
     #            'RDirs' : self.RDirs}
 
     def _morph(self):
         """Turn a file system node into a File object."""
@@ skipping 173 matching lines @@
         # rebuild anyway when it doesn't match the new content signature,
         # but that's probably the best we can do.
         import SCons.SConsign
         new_entry = SCons.SConsign.SConsignEntry()
         new_entry.binfo = self.new_binfo()
         binfo = new_entry.binfo
         for attr in self.convert_copy_attrs:
             try:
                 value = getattr(old_entry, attr)
             except AttributeError:
-                pass
-            else:
-                setattr(binfo, attr, value)
-                delattr(old_entry, attr)
+                continue
+            setattr(binfo, attr, value)
+            delattr(old_entry, attr)
         for attr in self.convert_sig_attrs:
             try:
                 sig_list = getattr(old_entry, attr)
             except AttributeError:
-                pass
-            else:
-                value = []
-                for sig in sig_list:
-                    ninfo = self.new_ninfo()
-                    if len(sig) == 32:
-                        ninfo.csig = sig
-                    else:
-                        ninfo.timestamp = sig
-                    value.append(ninfo)
-                setattr(binfo, attr, value)
-                delattr(old_entry, attr)
+                continue
+            value = []
+            for sig in sig_list:
+                ninfo = self.new_ninfo()
+                if len(sig) == 32:
+                    ninfo.csig = sig
+                else:
+                    ninfo.timestamp = sig
+                value.append(ninfo)
+            setattr(binfo, attr, value)
+            delattr(old_entry, attr)
         return new_entry
 
     memoizer_counters.append(SCons.Memoize.CountValue('get_stored_info'))
 
     def get_stored_info(self):
         try:
             return self._memo['get_stored_info']
         except KeyError:
             pass
 
@@ skipping 43 matching lines @@
         except KeyError:
             memo_dict = {}
             self._memo['get_found_includes'] = memo_dict
         else:
             try:
                 return memo_dict[memo_key]
             except KeyError:
                 pass
 
         if scanner:
+            # result = [n.disambiguate() for n in scanner(self, env, path)]
             result = scanner(self, env, path)
             result = map(lambda N: N.disambiguate(), result)
         else:
             result = []
 
         memo_dict[memo_key] = result
 
         return result
 
     def _createDir(self):
@@ skipping 83 matching lines @@
         source code builder for it.
 
         Note that if we found a source builder, we also set the
         self.builder attribute, so that all of the methods that actually
         *build* this file don't have to do anything different.
         """
         try:
             scb = self.sbuilder
         except AttributeError:
             scb = self.sbuilder = self.find_src_builder()
-        return not scb is None
+        return scb is not None
 
     def alter_targets(self):
         """Return any corresponding targets in a variant directory.
         """
         if self.is_derived():
             return [], None
         return self.fs.variant_dir_target_climb(self, self.dir, [self.name])
 
     def _rmv_existing(self):
         self.clear_memoized_values()
@@ skipping 52 matching lines @@
     memoizer_counters.append(SCons.Memoize.CountValue('exists'))
 
     def exists(self):
         try:
             return self._memo['exists']
         except KeyError:
             pass
         # Duplicate from source path if we are set up to do this.
         if self.duplicate and not self.is_derived() and not self.linked:
             src = self.srcnode()
-            if not src is self:
+            if src is not self:
                 # At this point, src is meant to be copied in a variant directory.
                 src = src.rfile()
                 if src.abspath != self.abspath:
                     if src.exists():
                         self.do_duplicate(src)
                         # Can't return 1 here because the duplication might
                         # not actually occur if the -n option is being used.
                     else:
                         # The source file does not exist.  Make sure no old
                         # copy remains in the variant directory.
@@ skipping 13 matching lines @@
 
     def get_max_drift_csig(self):
         """
         Returns the content signature currently stored for this node
         if it's been unmodified longer than the max_drift value, or the
         max_drift value is 0.  Returns None otherwise.
         """
         old = self.get_stored_info()
         mtime = self.get_timestamp()
 
-        csig = None
         max_drift = self.fs.max_drift
         if max_drift > 0:
             if (time.time() - mtime) > max_drift:
                 try:
                     n = old.ninfo
                     if n.timestamp and n.csig and n.timestamp == mtime:
-                        csig = n.csig
+                        return n.csig
                 except AttributeError:
                     pass
         elif max_drift == 0:
             try:
-                csig = old.ninfo.csig
+                return old.ninfo.csig
             except AttributeError:
                 pass
 
-        return csig
+        return None
 
     def get_csig(self):
         """
         Generate a node's content signature, the digested signature
         of its content.
 
         node - the node
         cache - alternate node to use for the signature cache
         returns - the content signature
         """
@@ skipping 34 matching lines @@
         self.changed_since_last_build = self.decide_target
 
     def changed_content(self, target, prev_ni):
         cur_csig = self.get_csig()
         try:
             return cur_csig != prev_ni.csig
         except AttributeError:
             return 1
 
     def changed_state(self, target, prev_ni):
-        return (self.state != SCons.Node.up_to_date)
+        return self.state != SCons.Node.up_to_date
 
     def changed_timestamp_then_content(self, target, prev_ni):
         if not self.changed_timestamp_match(target, prev_ni):
             try:
                 self.get_ninfo().csig = prev_ni.csig
             except AttributeError:
                 pass
             return False
         return self.changed_content(target, prev_ni)
 
@@ skipping 100 matching lines @@
 
     def get_cachedir_bsig(self):
         try:
             return self.cachesig
         except AttributeError:
             pass
 
         # Add the path to the cache signature, because multiple
         # targets built by the same action will all have the same
         # build signature, and we have to differentiate them somehow.
-        children =  self.children()
+        children = self.children()
+        executor = self.get_executor()
+        # sigs = [n.get_cachedir_csig() for n in children]
         sigs = map(lambda n: n.get_cachedir_csig(), children)
-        executor = self.get_executor()
         sigs.append(SCons.Util.MD5signature(executor.get_contents()))
         sigs.append(self.path)
-        self.cachesig = SCons.Util.MD5collect(sigs)
-        return self.cachesig
+        result = self.cachesig = SCons.Util.MD5collect(sigs)
+        return result
 
 
 default_fs = None
 
 def get_default_fs():
     global default_fs
     if not default_fs:
         default_fs = FS()
     return default_fs
 
@@ skipping 69 matching lines @@
             memo_dict = self._memo['find_file']
         except KeyError:
             memo_dict = {}
             self._memo['find_file'] = memo_dict
         else:
             try:
                 return memo_dict[memo_key]
             except KeyError:
                 pass
 
-        if verbose:
+        if verbose and not callable(verbose):
             if not SCons.Util.is_String(verbose):
                 verbose = "find_file"
-            if not callable(verbose):
-                verbose = '  %s: ' % verbose
-                verbose = lambda s, v=verbose: sys.stdout.write(v + s)
-        else:
-            verbose = lambda x: x
+            verbose = '  %s: ' % verbose
+            verbose = lambda s, v=verbose: sys.stdout.write(v + s)
 
         filedir, filename = os.path.split(filename)
         if filedir:
             # More compact code that we can't use until we drop
             # support for Python 1.5.2:
             #
             #def filedir_lookup(p, fd=filedir):
             #    """
             #    A helper function that looks up a directory for a file
             #    we're trying to find.  This only creates the Dir Node
@@ skipping 18 matching lines @@
             #    if isinstance(node, Dir) or isinstance(node, Entry):
             #        return node
             #    return None
             #paths = filter(None, map(filedir_lookup, paths))
 
             self.default_filedir = filedir
             paths = filter(None, map(self.filedir_lookup, paths))
 
         result = None
         for dir in paths:
-            verbose("looking for '%s' in '%s' ...\n" % (filename, dir))
+            if verbose:
+                verbose("looking for '%s' in '%s' ...\n" % (filename, dir))
             node, d = dir.srcdir_find_file(filename)
             if node:
-                verbose("... FOUND '%s' in '%s'\n" % (filename, d))
+                if verbose:
+                    verbose("... FOUND '%s' in '%s'\n" % (filename, d))
                 result = node
                 break
 
         memo_dict[memo_key] = result
 
         return result
 
 find_file = FileFinder().find_file
 
 
 def invalidate_node_memos(targets):
     """
     Invalidate the memoized values of all Nodes (files or directories)
     that are associated with the given entries. Has been added to
     clear the cache of nodes affected by a direct execution of an
     action (e.g.  Delete/Copy/Chmod). Existing Node caches become
     inconsistent if the action is run through Execute().  The argument
     `targets` can be a single Node object or filename, or a sequence
     of Nodes/filenames.
     """
     from traceback import extract_stack
 
     # First check if the cache really needs to be flushed. Only
     # actions run in the SConscript with Execute() seem to be
     # affected. XXX The way to check if Execute() is in the stacktrace
     # is a very dirty hack and should be replaced by a more sensible
     # solution.
-    must_invalidate = 0
-    tb = extract_stack()
-    for f in tb:
+    for f in extract_stack():
         if f[2] == 'Execute' and f[0][-14:] == 'Environment.py':
-            must_invalidate = 1
-    if not must_invalidate:
+            break
+    else:
+        # Dont have to invalidate, so return
         return
 
     if not SCons.Util.is_List(targets):
         targets = [targets]
     
     for entry in targets:
         # If the target is a Node object, clear the cache. If it is a
         # filename, look up potentially existing Node object first.
         try:
             entry.clear_memoized_values()
         except AttributeError:
             # Not a Node object, try to look up Node by filename.  XXX
             # This creates Node objects even for those filenames which
             # do not correspond to an existing Node object.
             node = get_default_fs().Entry(entry)
             if node:
                 node.clear_memoized_values()