Merged revisions 1582-1665 via svnmerge from

http://scons.tigris.org/svn/scons/branches/core

........
  r1585 | stevenknight | 2006-08-06 21:21:12 -0500 (Sun, 06 Aug 2006) | 1 line

  0.96.D430 - Fix bug with finding Fortran modules in build directories. (Nicolas Vigier)
........
  r1586 | stevenknight | 2006-08-06 22:54:39 -0500 (Sun, 06 Aug 2006) | 1 line

  0.96.D431 - Fix use of BuildDir when the source file is a relative-path symlink. (Nicola Vi
........
  r1587 | timot | 2006-08-10 14:45:00 -0500 (Thu, 10 Aug 2006) | 1 line

  fix Platform SDK init
........
  r1589 | stevenknight | 2006-08-12 13:28:51 -0500 (Sat, 12 Aug 2006) | 1 line

  0.96.D432 - Change the default mingw linker from g++ to gcc. (Mariusz Olko)
........
  r1590 | stevenknight | 2006-08-13 11:16:32 -0500 (Sun, 13 Aug 2006) | 1 line

  0.96.D433 - More runtest.py enhancements.
........
  r1594 | stevenknight | 2006-08-15 04:47:46 -0500 (Tue, 15 Aug 2006) | 1 line

  0.96.D434 - Print the full path of SConscript files in stack traces. (Dobes Vandermeer)
........
  r1600 | timot | 2006-08-16 11:34:44 -0500 (Wed, 16 Aug 2006) | 1 line

  add M4 to mingw tools
........
  r1611 | stevenknight | 2006-08-19 16:25:24 -0500 (Sat, 19 Aug 2006) | 1 line

  0.96.D435 - Add an SCons XMLResultStream to capture test results for mailing in. Get Aegis
........
  r1617 | timot | 2006-08-21 16:19:03 -0500 (Mon, 21 Aug 2006) | 1 line

  handling of spawnve returning an error code that is not in exitvalmap
........
  r1619 | stevenknight | 2006-09-01 19:07:47 -0500 (Fri, 01 Sep 2006) | 1 line

  0.96.D436 - Win32 test portability and other test fixes.
........
  r1620 | stevenknight | 2006-09-02 20:21:51 -0500 (Sat, 02 Sep 2006) | 2 lines

  Bring msvc.py in sync with Aegis repository.
........
  r1621 | stevenknight | 2006-09-02 20:23:48 -0500 (Sat, 02 Sep 2006) | 2 lines

  Move to keep symlink tests together.
........
  r1622 | garyo | 2006-09-06 11:51:42 -0500 (Wed, 06 Sep 2006) | 1 line

  Fix for Issue #1370; allow exit values not in exitvalmap.  Added some tests for this kind of thing.  Also improved win32 err msg if command exits with nonzero to show actual cmd, not just "cmd.exe".  Note this fix improves posix and win32 behavior.
........
  r1623 | stevenknight | 2006-09-07 06:35:16 -0500 (Thu, 07 Sep 2006) | 1 line

  0.96.D440 - Fix runtest.py with QMTest on Windows.
........
  r1625 | stevenknight | 2006-09-09 09:22:15 -0500 (Sat, 09 Sep 2006) | 3 lines

  Comment out a long-command test which fails on older Pythons (1.5.2)
  on Fedora Core 3.  We can restore it in the future.
........
  r1626 | stevenknight | 2006-09-09 16:17:44 -0500 (Sat, 09 Sep 2006) | 1 line

  0.96.D441 - Allow Python Values to be the targets of Builders. (Anonymous)
........
  r1627 | stevenknight | 2006-09-09 20:25:53 -0500 (Sat, 09 Sep 2006) | 1 line

  0.96.D442 - Support src_dir on SConscript() calls. (Dobes Vandermeer)
........
  r1628 | stevenknight | 2006-09-10 07:28:54 -0500 (Sun, 10 Sep 2006) | 1 line

  0.96.D443 - Add miscellaneous utility scripts and config changes.
........
  r1629 | stevenknight | 2006-09-11 04:45:01 -0500 (Mon, 11 Sep 2006) | 1 line

  0.96.D444 - Add a test case for BuildDir handling of nested SConscript files. (Adam Simpkin
........
  r1630 | stevenknight | 2006-09-11 11:34:07 -0500 (Mon, 11 Sep 2006) | 1 line

  0.96.D445 - Workaround bug in early versions of thePython 2.4 profiler.
........
  r1631 | stevenknight | 2006-09-19 19:12:51 -0500 (Tue, 19 Sep 2006) | 1 line

  0.96.D446 - Fix Visual Studio common prefix handling to only treat common prefixes on comple
........
  r1632 | stevenknight | 2006-09-25 07:11:44 -0500 (Mon, 25 Sep 2006) | 1 line

  0.96.D447 - Fix tests that fail due to warnings from (some versions?) of gcc. (Sohail Soman
........
  r1633 | stevenknight | 2006-09-25 07:57:48 -0500 (Mon, 25 Sep 2006) | 1 line

  0.96.D448 - Handle python paths with quotes in tests.
........
  r1634 | stevenknight | 2006-09-25 14:38:07 -0500 (Mon, 25 Sep 2006) | 1 line

  0.96.D449 - Fix SCons build when python is not in the path (e.g. on Windows). (Chad Austin)
........
  r1635 | stevenknight | 2006-09-26 11:28:23 -0500 (Tue, 26 Sep 2006) | 1 line

  0.96.D450 - Handle warnings from Python 2.1; make sure we still test on Python 1.5.
........
  r1636 | stevenknight | 2006-09-27 05:34:23 -0500 (Wed, 27 Sep 2006) | 1 line

  0.96.D451 - Avoid calling Options validators and converters twice.
........
  r1637 | stevenknight | 2006-09-28 08:12:38 -0500 (Thu, 28 Sep 2006) | 1 line

  0.96.D452 - Allow setting MSVS_VERSION after initialization to select the Visual Studio vers
........
  r1638 | stevenknight | 2006-09-30 08:38:15 -0500 (Sat, 30 Sep 2006) | 1 line

  0.96.D453 - Give the MSVC resource builder a src_builder list and .rc src_suffix. (Leanid N
........
  r1639 | stevenknight | 2006-10-12 08:50:58 -0500 (Thu, 12 Oct 2006) | 1 line

  0.96.D454 - Test handling of env.Append() and env.Prepend(), making sure it works on later P
........
  r1640 | stevenknight | 2006-10-15 20:42:09 -0500 (Sun, 15 Oct 2006) | 1 line

  0.96.D455 - Support the runtest.py -f option when using QMTest.
........
  r1641 | stevenknight | 2006-10-15 21:20:02 -0500 (Sun, 15 Oct 2006) | 1 line

  0.96.D456 - Fix an error in ListOption handling caused by making new copies of Options objec
........
  r1642 | stevenknight | 2006-10-16 05:53:14 -0500 (Mon, 16 Oct 2006) | 1 line

  0.96.D457 - Fix new Append()/Prepend() handling of dictionaries in later Python versions (2.
........
  r1643 | stevenknight | 2006-10-16 07:13:16 -0500 (Mon, 16 Oct 2006) | 1 line

  0.96.D458 - Allow Install() to handle directories as sources. (Matthew A. Nicholson)
........
  r1644 | stevenknight | 2006-10-17 09:17:58 -0500 (Tue, 17 Oct 2006) | 1 line

  0.96.D459 - Add a test to make sure SideEffect() doesn't interfere with CacheDir(). Refacto
........
  r1645 | stevenknight | 2006-10-17 10:20:22 -0500 (Tue, 17 Oct 2006) | 1 line

  0.96.D460 - Do not use -fPIC when using gcc on win32 (MinGW). (Jan Nijtmans)
........
  r1646 | stevenknight | 2006-10-17 17:21:58 -0500 (Tue, 17 Oct 2006) | 6 lines

  Move all the scons.org stuff from the scons source tree itself to a
  directory next to the trunk, and delete the copies from the branches.
  There's a lot of stuff there (what with all of the documentation of
  the different versions) and it's ridiculous to make everyone sync it
  just to work on the code.
........
  r1647 | stevenknight | 2006-10-17 23:18:29 -0500 (Tue, 17 Oct 2006) | 1 line

  0.96.D461 - Fix the tests of runtest.py so they skip appropriately if qmtest.py isn't instal
........
  r1648 | stevenknight | 2006-10-18 08:48:47 -0500 (Wed, 18 Oct 2006) | 1 line

  0.96.D462 - When using --implicit-cache, do not re-scan files if the scanner returned no imp
........
  r1649 | stevenknight | 2006-10-18 19:42:13 -0500 (Wed, 18 Oct 2006) | 1 line

  0.96.D463 - More test portability fixes.
........
  r1650 | stevenknight | 2006-10-19 00:30:23 -0500 (Thu, 19 Oct 2006) | 1 line

  0.96.D464 - Add a cpp.py module that knows how to find dependencies from #include lines like
........
  r1651 | stevenknight | 2006-10-20 06:49:51 -0500 (Fri, 20 Oct 2006) | 1 line

  0.96.D465 - Fix unresolved variable name in win32 portion of test.
........
  r1652 | stevenknight | 2006-10-23 00:20:38 -0500 (Mon, 23 Oct 2006) | 1 line

  0.96.D466 - Add an option for tracing files to and from the CacheDir.
........
  r1653 | stevenknight | 2006-10-23 00:29:32 -0500 (Mon, 23 Oct 2006) | 1 line

  0.96.D467 - Make {Append,Prepend}Unique() handle adding elements to empty lists like {Append
........
  r1654 | stevenknight | 2006-10-23 02:38:06 -0500 (Mon, 23 Oct 2006) | 1 line

  0.96.D468 - Allow Debug.caller() to take multiple arguments; add a debug utility to post-pro
........
  r1655 | stevenknight | 2006-10-23 03:16:42 -0500 (Mon, 23 Oct 2006) | 1 line

  0.96.D469 - Reduce unnecessary calls to Node.FS.disambiguate(), undoing (?) a performance hi
........
  r1656 | stevenknight | 2006-10-25 00:06:27 -0500 (Wed, 25 Oct 2006) | 1 line

  0.96.D470 - More test portability fixes.
........
  r1657 | stevenknight | 2006-10-25 00:16:22 -0500 (Wed, 25 Oct 2006) | 1 line

  0.96.D471 - Have runtest.py fall back to the --noqmtest option (with a warning) if qmtest.py
........
  r1658 | stevenknight | 2006-10-25 12:12:02 -0500 (Wed, 25 Oct 2006) | 1 line

  0.96.D472 - Document the default use of the /Z7 flag for Visual Studio and ways to use /Zi.
........
  r1659 | stevenknight | 2006-10-26 23:53:51 -0500 (Thu, 26 Oct 2006) | 1 line

  0.96.D473 - Have runtest.py -d accomodate different Python library locations.
........
  r1660 | stevenknight | 2006-10-27 00:03:59 -0500 (Fri, 27 Oct 2006) | 1 line

  0.96.D474 - Patch to support running SCons under WingIDE. (Allen Bierbaum)
........
  r1661 | stevenknight | 2006-10-27 12:17:27 -0500 (Fri, 27 Oct 2006) | 1 line

  0.96.D475 - Restore execution of all Environment unit tests.
........
  r1662 | stevenknight | 2006-10-31 23:22:58 -0600 (Tue, 31 Oct 2006) | 1 line

  0.96.D476 - Eliminate unnecessary print from a test, left over from debugging.
........
  r1663 | stevenknight | 2006-10-31 23:32:00 -0600 (Tue, 31 Oct 2006) | 1 line

  0.96.D477 - Support creating shared object files from assembly language. (James Y. Knight)
........
  r1664 | stevenknight | 2006-10-31 23:44:08 -0600 (Tue, 31 Oct 2006) | 1 line

  0.96.D478 - Fix the Memoizer to deal with a compiled .pyo or .pyc file that's in a different
........
  r1665 | stevenknight | 2006-11-01 21:59:18 -0600 (Wed, 01 Nov 2006) | 1 line

  0.96.D479 - Put back the scons-{LICENSE,README} files in the scons-loacal package; add tests
........

5 files changed, 163 insertions, 77 deletions

diff --git a/src/engine/SCons/Node/FS.py b/src/engine/SCons/Node/FS.py
index ce5bcc0..382bca3 100644
--- a/src/engine/SCons/Node/FS.py
+++ b/src/engine/SCons/Node/FS.py
@@ -95,10 +95,33 @@ def save_strings(val):
 # there should be *no* changes to the external file system(s)...
 #
 
-def _copy_func(src, dest):
+if hasattr(os, 'link'):
+    def _hardlink_func(fs, src, dst):
+        # If the source is a symlink, we can't just hard-link to it
+        # because a relative symlink may point somewhere completely
+        # different.  We must disambiguate the symlink and then
+        # hard-link the final destination file.
+        while fs.islink(src):
+            link = fs.readlink(src)
+            if not os.path.isabs(link):
+                src = link
+            else:
+                src = os.path.join(os.path.dirname(src), link)
+        fs.link(src, dst)
+else:
+    _hardlink_func = None
+
+if hasattr(os, 'symlink'):
+    def _softlink_func(fs, src, dst):
+        fs.symlink(src, dst)
+else:
+    _softlink_func = None
+
+def _copy_func(fs, src, dest):
     shutil.copy2(src, dest)
-    st=os.stat(src)
-    os.chmod(dest, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)
+    st = fs.stat(src)
+    fs.chmod(dest, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)
+
 
 Valid_Duplicates = ['hard-soft-copy', 'soft-hard-copy',
                     'hard-copy', 'soft-copy', 'copy']
@@ -113,16 +136,6 @@ def set_duplicate(duplicate):
     # underlying implementations.  We do this inside this function,
     # not in the top-level module code, so that we can remap os.link
     # and os.symlink for testing purposes.
-    try:
-        _hardlink_func = os.link
-    except AttributeError:
-        _hardlink_func = None
-
-    try:
-        _softlink_func = os.symlink
-    except AttributeError:
-        _softlink_func = None
-
     link_dict = {
         'hard' : _hardlink_func,
         'soft' : _softlink_func,
@@ -152,10 +165,11 @@ def LinkFunc(target, source, env):
     if not Link_Funcs:
         # Set a default order of link functions.
         set_duplicate('hard-soft-copy')
+    fs = source[0].fs
     # Now link the files with the previously specified order.
     for func in Link_Funcs:
         try:
-            func(src,dest)
+            func(fs, src, dest)
             break
         except (IOError, OSError):
             # An OSError indicates something happened like a permissions
@@ -213,13 +227,15 @@ def CacheRetrieveFunc(target, source, env):
     t = target[0]
     fs = t.fs
     cachedir, cachefile = t.cachepath()
-    if fs.exists(cachefile):
-        if SCons.Action.execute_actions:
-            fs.copy2(cachefile, t.path)
-            st = fs.stat(cachefile)
-            fs.chmod(t.path, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)
-        return 0
-    return 1
+    if not fs.exists(cachefile):
+        fs.CacheDebug('CacheRetrieve(%s):  %s not in cache\n', t, cachefile)
+        return 1
+    fs.CacheDebug('CacheRetrieve(%s):  retrieving from %s\n', t, cachefile)
+    if SCons.Action.execute_actions:
+        fs.copy2(cachefile, t.path)
+        st = fs.stat(cachefile)
+        fs.chmod(t.path, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)
+    return 0
 
 def CacheRetrieveString(target, source, env):
     t = target[0]
@@ -237,9 +253,18 @@ def CachePushFunc(target, source, env):
     fs = t.fs
     cachedir, cachefile = t.cachepath()
     if fs.exists(cachefile):
-        # Don't bother copying it if it's already there.
+        # Don't bother copying it if it's already there.  Note that
+        # usually this "shouldn't happen" because if the file already
+        # existed in cache, we'd have retrieved the file from there,
+        # not built it.  This can happen, though, in a race, if some
+        # other person running the same build pushes their copy to
+        # the cache after we decide we need to build it but before our
+        # build completes.
+        fs.CacheDebug('CachePush(%s):  %s already exists in cache\n', t, cachefile)
         return
 
+    fs.CacheDebug('CachePush(%s):  pushing to %s\n', t, cachefile)
+
     if not fs.isdir(cachedir):
         fs.makedirs(cachedir)
 
@@ -258,7 +283,6 @@ def CachePushFunc(target, source, env):
         SCons.Warnings.warn(SCons.Warnings.CacheWriteErrorWarning,
                             "Unable to copy %s to cache. Cache file is %s"
                                 % (str(target), cachefile))
-        return
 
 CachePush = SCons.Action.Action(CachePushFunc, None)
 
@@ -835,6 +859,14 @@ class LocalFS:
         def islink(self, path):
             return 0                    # no symlinks
 
+    if hasattr(os, 'readlink'):
+        def readlink(self, file):
+            return os.readlink(file)
+    else:
+        def readlink(self, file):
+            return ''
+
+
 if SCons.Memoize.use_old_memoization():
     _FSBase = LocalFS
     class LocalFS(SCons.Memoize.Memoizer, _FSBase):
@@ -1139,6 +1171,21 @@ class FS(LocalFS):
             result.extend(dir.get_all_rdirs())
         return result
 
+    def CacheDebugWrite(self, fmt, target, cachefile):
+        self.CacheDebugFP.write(fmt % (target, os.path.split(cachefile)[1]))
+
+    def CacheDebugQuiet(self, fmt, target, cachefile):
+        pass
+
+    CacheDebug = CacheDebugQuiet
+
+    def CacheDebugEnable(self, file):
+        if file == '-':
+            self.CacheDebugFP = sys.stdout
+        else:
+            self.CacheDebugFP = open(file, 'w')
+        self.CacheDebug = self.CacheDebugWrite
+
     def CacheDir(self, path):
         self.CachePath = path
 
@@ -1776,7 +1823,7 @@ class File(Base):
         __cacheable__"""
         if not scanner:
             return []
-        return map(lambda N: N.disambiguate(), scanner(self, env, path))
+        return scanner(self, env, path)
 
     def _createDir(self):
         # ensure that the directories for this node are
@@ -1818,11 +1865,14 @@ class File(Base):
             if self.fs.cache_show:
                 if CacheRetrieveSilent(self, [], None, execute=1) == 0:
                     self.build(presub=0, execute=0)
+                    self.set_state(SCons.Node.executed)
                     return 1
             elif CacheRetrieve(self, [], None, execute=1) == 0:
+                self.set_state(SCons.Node.executed)
                 return 1
         return None
 
+
     def built(self):
         """Called just after this node is successfully built.
         __cache_reset__"""
diff --git a/src/engine/SCons/Node/FSTests.py b/src/engine/SCons/Node/FSTests.py
index 98e08a9..1b38ffe 100644
--- a/src/engine/SCons/Node/FSTests.py
+++ b/src/engine/SCons/Node/FSTests.py
@@ -425,57 +425,39 @@ class BuildDirTestCase(unittest.TestCase):
         class LinkSimulator :
             """A class to intercept os.[sym]link() calls and track them."""
 
-            def __init__( self, duplicate ) :
+            def __init__( self, duplicate, link, symlink, copy ) :
                 self.duplicate = duplicate
-                self._reset()
-
-            def _reset( self ) :
-                """Reset the simulator if necessary"""
-                if not self._need_reset() : return # skip if not needed now
-                self.links_to_be_called = self.duplicate
-
-            def _need_reset( self ) :
-                """
-                Determines whether or not the simulator needs to be reset.
-                A reset is necessary if the object is first being initialized,
-                or if all three methods have been tried already.
-                """
-                return (
-                        ( not hasattr( self , "links_to_be_called" ) )
-                        or
-                        (self.links_to_be_called == "")
-                       )
+                self.have = {}
+                self.have['hard'] = link
+                self.have['soft'] = symlink
+                self.have['copy'] = copy
+
+                self.links_to_be_called = []
+                for link in string.split(self.duplicate, '-'):
+                    if self.have[link]:
+                        self.links_to_be_called.append(link)
 
             def link_fail( self , src , dest ) :
-                self._reset()
-                l = string.split(self.links_to_be_called, "-")
-                next_link = l[0]
-                assert  next_link == "hard", \
+                next_link = self.links_to_be_called.pop(0)
+                assert next_link == "hard", \
                        "Wrong link order: expected %s to be called "\
                        "instead of hard" % next_link
-                self.links_to_be_called = string.join(l[1:], '-')
                 raise OSError( "Simulating hard link creation error." )
 
             def symlink_fail( self , src , dest ) :
-                self._reset()
-                l = string.split(self.links_to_be_called, "-")
-                next_link = l[0]
-                assert  next_link == "soft", \
+                next_link = self.links_to_be_called.pop(0)
+                assert next_link == "soft", \
                        "Wrong link order: expected %s to be called "\
                        "instead of soft" % next_link
-                self.links_to_be_called = string.join(l[1:], '-')
                 raise OSError( "Simulating symlink creation error." )
 
             def copy( self , src , dest ) :
-                self._reset()
-                l = string.split(self.links_to_be_called, "-")
-                next_link = l[0]
-                assert  next_link == "copy", \
+                next_link = self.links_to_be_called.pop(0)
+                assert next_link == "copy", \
                        "Wrong link order: expected %s to be called "\
                        "instead of copy" % next_link
-                self.links_to_be_called = string.join(l[1:], '-')
                 # copy succeeds, but use the real copy
-                self._real_copy(src, dest)
+                self.have['copy'](src, dest)
         # end class LinkSimulator
 
         try:
@@ -485,32 +467,31 @@ class BuildDirTestCase(unittest.TestCase):
             pass
 
         for duplicate in SCons.Node.FS.Valid_Duplicates:
-            simulator = LinkSimulator(duplicate)
-
             # save the real functions for later restoration
-            real_link = None
-            real_symlink = None
             try:
                 real_link = os.link
             except AttributeError:
-                pass
+                real_link = None
             try:
                 real_symlink = os.symlink
             except AttributeError:
-                pass
+                real_symlink = None
             real_copy = shutil.copy2
-            simulator._real_copy = real_copy # the simulator needs the real one
+
+            simulator = LinkSimulator(duplicate, real_link, real_symlink, real_copy)
 
             # override the real functions with our simulation
             os.link = simulator.link_fail
             os.symlink = simulator.symlink_fail
             shutil.copy2 = simulator.copy
-            SCons.Node.FS.set_duplicate(duplicate)
-
-            src_foo = test.workpath('src', 'foo')
-            build_foo = test.workpath('build', 'foo')
 
             try:
+
+                SCons.Node.FS.set_duplicate(duplicate)
+
+                src_foo = test.workpath('src', 'foo')
+                build_foo = test.workpath('build', 'foo')
+
                 test.write(src_foo, 'src/foo\n')
                 os.chmod(src_foo, stat.S_IRUSR)
                 try:
diff --git a/src/engine/SCons/Node/Python.py b/src/engine/SCons/Node/Python.py
index 99dc5b0..a639aee 100644
--- a/src/engine/SCons/Node/Python.py
+++ b/src/engine/SCons/Node/Python.py
@@ -45,16 +45,18 @@ class Value(SCons.Node.Node):
     NodeInfo = ValueNodeInfo
     BuildInfo = ValueBuildInfo
 
-    def __init__(self, value):
+    def __init__(self, value, built_value=None):
         SCons.Node.Node.__init__(self)
         self.value = value
+        if not built_value is None:
+            self.built_value = built_value
 
     def __str__(self):
         return repr(self.value)
 
-    def build(self):
-        """A "builder" for Values."""
-        pass
+    def build(self, **kw):
+        if not hasattr(self, 'built_value'):
+            apply (SCons.Node.Node.build, (self,), kw)
 
     current = SCons.Node.Node.children_are_up_to_date
 
@@ -64,9 +66,23 @@ class Value(SCons.Node.Node):
         # are outside the filesystem:
         return 1
 
+    def write(self, built_value):
+        """Set the value of the node."""
+        self.built_value = built_value
+
+    def read(self):
+        """Return the value. If necessary, the value is built."""
+        self.build()
+        if not hasattr(self, 'built_value'):
+            self.built_value = self.value
+        return self.built_value
+
     def get_contents(self):
-        """The contents of a Value are the concatenation
-        of all the contents of its sources with the node's value itself."""
+        """By the assumption that the node.built_value is a
+        deterministic product of the sources, the contents of a Value
+        are the concatenation of all the contents of its sources.  As
+        the value need not be built when get_contents() is called, we
+        cannot use the actual node.built_value."""
         contents = str(self.value)
         for kid in self.children(None):
             contents = contents + kid.get_contents()
diff --git a/src/engine/SCons/Node/PythonTests.py b/src/engine/SCons/Node/PythonTests.py
index 0801fb3..62bcf8b 100644
--- a/src/engine/SCons/Node/PythonTests.py
+++ b/src/engine/SCons/Node/PythonTests.py
@@ -45,6 +45,44 @@ class ValueTestCase(unittest.TestCase):
         assert not v1 is v2
         assert v1.value == v2.value
 
+        v3 = SCons.Node.Python.Value('c', 'cb')
+        assert v3.built_value == 'cb'
+
+    def test_build(self):
+        """Test "building" a Value Node
+        """
+        class fake_executor:
+            def __call__(self, node, exitstatfunc):
+                node.write('faked')
+
+        v1 = SCons.Node.Python.Value('b', 'built')
+        v1.executor = fake_executor()
+        v1.build()
+        assert v1.built_value == 'built', v1.built_value
+
+        v2 = SCons.Node.Python.Value('b')
+        v2.executor = fake_executor()
+        v2.build()
+        assert v2.built_value == 'faked', v2.built_value
+
+    def test_read(self):
+        """Test the Value.read() method
+        """
+        v1 = SCons.Node.Python.Value('a')
+        x = v1.read()
+        assert x == 'a', x
+
+    def test_write(self):
+        """Test the Value.write() method
+        """
+        v1 = SCons.Node.Python.Value('a')
+        assert v1.value == 'a', v1.value
+        assert not hasattr(v1, 'built_value')
+
+        v1.write('new')
+        assert v1.value == 'a', v1.value
+        assert v1.built_value == 'new', v1.built_value
+
     def test_get_csig(self):
         """Test calculating the content signature of a Value() object
         """
diff --git a/src/engine/SCons/Node/__init__.py b/src/engine/SCons/Node/__init__.py
index bda3a48..42be5b1 100644
--- a/src/engine/SCons/Node/__init__.py
+++ b/src/engine/SCons/Node/__init__.py
@@ -474,6 +474,7 @@ class Node:
             d = filter(lambda x, seen=seen: not seen.has_key(x),
                        n.get_found_includes(env, scanner, path))
             if d:
+                d = map(lambda N: N.disambiguate(), d)
                 deps.extend(d)
                 for n in d:
                     seen[n] = 1
@@ -538,7 +539,7 @@ class Node:
         # Here's where we implement --implicit-cache.
         if implicit_cache and not implicit_deps_changed:
             implicit = self.get_stored_implicit()
-            if implicit:
+            if implicit is not None:
                 factory = build_env.get_factory(self.builder.source_factory)
                 nodes = []
                 for i in implicit: