Merged revisions 2647-2719 via svnmerge from

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

........
  r2649 | stevenknight | 2008-02-08 06:43:30 -0800 (Fri, 08 Feb 2008) | 3 lines

  Make the "bootstrap" copy directory relative to the script location
  regardless of where the user is when executing.
........
  r2650 | stevenknight | 2008-02-09 09:26:40 -0800 (Sat, 09 Feb 2008) | 3 lines

  Chdir back to the original directory before removing our temporary
  directory, to avoid "Permission denied" errors on Windows.
........
  r2651 | stevenknight | 2008-02-09 10:02:09 -0800 (Sat, 09 Feb 2008) | 3 lines

  Fix floating-point numbers confusing our notion of the .class
  files that will be generated in certain configurations.
........
  r2652 | stevenknight | 2008-02-09 10:26:48 -0800 (Sat, 09 Feb 2008) | 4 lines

  Issue 1868:  change the RootDir "lookup path" from '/' to '' so that
  looking up '/foo' returns the same node as looking up 'foo' when the
  current directory is the root.
........
  r2653 | stevenknight | 2008-02-09 11:16:17 -0800 (Sat, 09 Feb 2008) | 3 lines

  Issue 1902:  Document all the values that can now be fetched with GetOption.
  Additional formatting cleanups.
........
  r2654 | stevenknight | 2008-02-09 11:37:50 -0800 (Sat, 09 Feb 2008) | 3 lines

  Fix handling file names that contain substrings of multiple spaces
  when using ActionFactory instances like Copy() and Move().
........
  r2655 | stevenknight | 2008-02-09 13:36:14 -0800 (Sat, 09 Feb 2008) | 3 lines

  Issue 1898:  Fix use of a variable expansion in a source file name
  (like foo$OBJSUFFIX) when trying to match source builder suffixes.
........
  r2656 | stevenknight | 2008-02-09 20:58:32 -0800 (Sat, 09 Feb 2008) | 3 lines

  Issue 1903:  don't allow Java generics syntax to interfere with
  identifying an anonymous inner class.
........
  r2657 | stevenknight | 2008-02-09 21:02:37 -0800 (Sat, 09 Feb 2008) | 3 lines

  Left out the \w from the regular expression that matches generics,
  so we wouldn't match alphanumerics, only alphabetics.
........
  r2658 | stevenknight | 2008-02-09 23:33:03 -0800 (Sat, 09 Feb 2008) | 3 lines

  Issue 1899:  Enhance Chmod(), Delete(), Mkdir() and Touch() to take
  lists of Nodes or strings.
........
  r2659 | stevenknight | 2008-02-10 00:15:24 -0800 (Sun, 10 Feb 2008) | 4 lines

  Issue 1878:  Add comment lines to the generated config.h file describing
  the intent of the various #define/#undef lines.
  (David Cournapeau)
........
  r2660 | stevenknight | 2008-02-11 18:15:27 -0800 (Mon, 11 Feb 2008) | 3 lines

  Issue 1682:  Fix the ability to save and restore the ListOption value
  'all' in newer Python versions that have an all() built-in function.
........
  r2661 | stevenknight | 2008-02-27 07:25:18 -0800 (Wed, 27 Feb 2008) | 3 lines

  Issue 1919:  Optimize the SCons.Util.is_*() and SCons.Util.flatten()
  functions.  More efficient suffix selection in Selector.__call__() method.
........
  r2662 | stevenknight | 2008-02-28 06:43:29 -0800 (Thu, 28 Feb 2008) | 3 lines

  Fix SCons.Util.is_List() method to use the passed-in ListTypes variable.
  (Daniel Svensson)
........
  r2663 | stevenknight | 2008-02-28 06:57:44 -0800 (Thu, 28 Feb 2008) | 4 lines

  Issue 1884:  avoid an infinite loop when trying to use saved copies of
  the ToolInitializer objects that we use to initialize the env.Install()
  and env.InstallAs() methods.
........
  r2664 | garyo | 2008-02-28 07:25:25 -0800 (Thu, 28 Feb 2008) | 1 line

  Fix long-style command-line args in runtest.py (they were missing from getopt call).
........
  r2665 | garyo | 2008-02-28 09:31:42 -0800 (Thu, 28 Feb 2008) | 1 line

  runtest.py: Use qmtest instead of qmtest.py; newer QMTest releases may only have qmtest in /usr/bin.
........
  r2666 | stevenknight | 2008-02-28 12:10:02 -0800 (Thu, 28 Feb 2008) | 3 lines

  Remove dead code that was at one time apparently intended to grab the
  external environment's %INCLUDE% values.
........
  r2667 | stevenknight | 2008-02-28 12:16:40 -0800 (Thu, 28 Feb 2008) | 3 lines

  Move the regular expression and function that check for whether a
  construction variable name is legal from Util.py to Environment.py.
........
  r2668 | stevenknight | 2008-02-28 20:24:36 -0800 (Thu, 28 Feb 2008) | 2 lines

  Fix qmtest.py references (replace with qmtest) in tests and infrastructure.
........
  r2669 | stevenknight | 2008-02-28 20:27:05 -0800 (Thu, 28 Feb 2008) | 7 lines

  Speed up the SubstitionEnvironment.__setitem__() method by: 1) avoiding
  checking for whether the variable name is legal if it already exists; 2)
  use the regular expression directly when checking the form for illegality;
  3) more efficient check for whether a variable name is special.  Add a
  timing script so we can document why we implemented it as we did and
  revisit it in the future if need be.
........
  r2670 | stevenknight | 2008-02-28 20:51:44 -0800 (Thu, 28 Feb 2008) | 2 lines

  Add a shell script that generates context-diff output for review.
........
  r2671 | GregNoel | 2008-03-01 00:40:16 -0800 (Sat, 01 Mar 2008) | 1 line

  add test to env.__setitem__ benchmark
........
  r2672 | GregNoel | 2008-03-01 02:00:12 -0800 (Sat, 01 Mar 2008) | 1 line

  compatibility changes for env.__setitem__ benchmark
........
  r2673 | stevenknight | 2008-03-01 09:56:57 -0800 (Sat, 01 Mar 2008) | 3 lines

  Capture a vanilla copy of the Python 2.[45] timeit.py module, as a
  basis for being able to use this to time Python 2.2 (and earlier).
........
  r2674 | stevenknight | 2008-03-01 10:04:11 -0800 (Sat, 01 Mar 2008) | 3 lines

  Work around a race in the order in which we detect and report the build
  failures by letting the error messages show up in either order on stdout.
........
  r2675 | stevenknight | 2008-03-01 10:05:24 -0800 (Sat, 01 Mar 2008) | 3 lines

  Back-port the captured timeit.py module, and the env.__setitem__.py
  script itself, to Python versions before 2.3.
........
  r2676 | GregNoel | 2008-03-01 14:01:03 -0800 (Sat, 01 Mar 2008) | 1 line

  add banner information, remove inadvertent tabs
........
  r2677 | stevenknight | 2008-03-02 05:04:52 -0800 (Sun, 02 Mar 2008) | 3 lines

  Don't look for a Copyright string in the source-packaged bench/timeit.py
  module that we captured.
........
  r2678 | stevenknight | 2008-03-02 14:59:39 -0800 (Sun, 02 Mar 2008) | 6 lines

  Issue 1884:  Allow env.{Install,InstallAs}() to be replaced by user-
  supplied wrappers that call the underlying builder.

  Fix how environment cloning so it only clones dynamically-added method
  attributes that the user hasn't also overwritten explicity.
........
  r2679 | stevenknight | 2008-03-04 07:48:53 -0800 (Tue, 04 Mar 2008) | 3 lines

  Fix env.{Dir,Entry,File}() when the input is a list, broken last December
  when env.subst() was modified to return lists as-is.
........
  r2680 | stevenknight | 2008-03-04 08:24:06 -0800 (Tue, 04 Mar 2008) | 2 lines

  Fix printing Python Value Nodes in --debug=explain output.  (Jim Randall)
........
  r2681 | garyo | 2008-03-04 12:37:39 -0800 (Tue, 04 Mar 2008) | 1 line

  Make File(), Dir() and Entry() return lists when passed a sequence.
........
  r2682 | garyo | 2008-03-05 15:24:00 -0800 (Wed, 05 Mar 2008) | 1 line

  InstallBuilderWrapper and InstallBuilderWrapper should accept keyword args and pass them to the base builder, like other builders.
........
  r2683 | stevenknight | 2008-03-06 06:32:13 -0800 (Thu, 06 Mar 2008) | 2 lines

  Python 1.5.2 compatibility:  use apply() instead of **kw.
........
  r2684 | garyo | 2008-03-14 13:07:09 -0700 (Fri, 14 Mar 2008) | 1 line

  Fix QMTest problem with $TERM variable in user's environment causing test failures.
........
  r2685 | bdbaddog | 2008-03-14 13:16:20 -0700 (Fri, 14 Mar 2008) | 13 lines

  * Added java_where_includes - gets path list for java JDK's include dirs
  * Added java_where_java_home - gets  JAVA_HOME  path
  * Added path's to find java for sun's JDK rpm install to java_where_jar
  * moved paths() to be outside of java_ENV() routine and available for other routines to use as well as tests
  * set TERM to be dumb to fix broken readline causing massive failures on FC8 (only updated Gary's comments to include note about broken FC8 readline, as Gary committed the TERM just prior to my checkin)
  * Modified the following tests to use the above changes:
     * test/SWIG/SWIGOUTDIR.py
     * test/Java/swig-dependencies.py
     * test/Java/multi-step.py
     * test/Repository/Java.py
     * test/runtest/fallback.py  [ This test also has been changed to remove more than one qmtest in your PATH, previously it would only remove one path which had qmtest, my system had a local and a system version ]
........
  r2686 | stevenknight | 2008-03-15 20:50:07 -0700 (Sat, 15 Mar 2008) | 4 lines

  Add a warning about deprecating support for Python versions 1.5, 2.0
  and 2.1.  Fix the ability to SetOption('warn') so people can disable
  the warning by adding something to a SConscript file.
........
  r2687 | stevenknight | 2008-03-15 21:48:26 -0700 (Sat, 15 Mar 2008) | 3 lines

  Issue 1942:  Document the Dir(), File() and Entry() methods of Dir
  and File Nodes.  (Greg Noel)
........
  r2688 | GregNoel | 2008-03-16 00:05:04 -0700 (Sun, 16 Mar 2008) | 1 line

  Add parse_flags keyword option
........
  r2689 | stevenknight | 2008-03-16 00:32:33 -0700 (Sun, 16 Mar 2008) | 3 lines

  Print a message if we're skipping the build of a package because the
  necessary underlying tool doesn't exist.
........
  r2690 | stevenknight | 2008-03-16 00:40:28 -0700 (Sun, 16 Mar 2008) | 7 lines

  Add --warn=no-python-version to the $SCONSFLAGS variable when running
  tests under deprecated Python versions, so the warning doesn't interfere
  with running normal tests under those version.

  Have the test/python-version.py remove --warn=no-python-version from the
  $SCONSFLAGS variable, since it's explicitly testing that behavior.
........
  r2691 | stevenknight | 2008-03-16 08:20:54 -0700 (Sun, 16 Mar 2008) | 4 lines

  Handle ripple effects from setting $SCONSFLAGS to suppress the deprecation
  under older Python versions by commonizing and moving much of the logic
  in QMTest/TestSCons.py.
........
  r2692 | stevenknight | 2008-03-16 08:47:52 -0700 (Sun, 16 Mar 2008) | 5 lines

  Update the warning message for running under a deprecated Python
  version (text courtesy Greg Noel).  Make that warning a subclass of the
  DeprecatedWarning class, so the message can also be disabled by setting
  --warn=no-deprecated.
........
  r2693 | stevenknight | 2008-03-16 11:19:52 -0700 (Sun, 16 Mar 2008) | 4 lines

  Shorten the deprecated-python-version warning.
  Use sys.version_info to check, instead of hard-coded string comparisons.
  Edit the release note.
........
  r2694 | stevenknight | 2008-03-16 11:29:10 -0700 (Sun, 16 Mar 2008) | 3 lines

  Have the warning mention both that 2.2 is the base un-deprecated version
  and the version they're running without getting too wordy.
........
  r2695 | stevenknight | 2008-03-16 12:00:22 -0700 (Sun, 16 Mar 2008) | 2 lines

  Skip test/SWIG/SWIGOUTDIR.py if no installed jni.h files are found.
........
  r2696 | stevenknight | 2008-03-18 18:01:46 -0700 (Tue, 18 Mar 2008) | 2 lines

  Remove old, commented-out deprecation test code.
........
  r2697 | stevenknight | 2008-03-19 17:54:55 -0700 (Wed, 19 Mar 2008) | 2 lines

  Deprecate env.Copy() with a suppressable message.
........
  r2699 | stevenknight | 2008-03-20 08:20:22 -0700 (Thu, 20 Mar 2008) | 2 lines

  Move the debug-nomemoizer.py test to the test/Deprecated subdirectory.
........
  r2700 | stevenknight | 2008-03-20 08:37:51 -0700 (Thu, 20 Mar 2008) | 2 lines

  Issue 1954:  Adds deprecation warnings for --debug={dtree,stree,tree}.
........
  r2701 | stevenknight | 2008-03-23 00:33:25 -0700 (Sun, 23 Mar 2008) | 7 lines

  Add VariantDir() as a replacement for BuildDir().
  Change "build directory" references in text (comments and
  documentation) to "variant directory."
  Move and rename tests that named BuildDir in their path.
  Add a release note about the forthcoming deprecation of BuildDir().
  Add a test/Deprecated/BuildDir.py to track backwards compatibility.
........
  r2702 | stevenknight | 2008-03-24 11:23:39 -0700 (Mon, 24 Mar 2008) | 4 lines

  Change the VariantDir() and SConscrip "build_dir" keyword to "variant_dir."
  Still support "build_dir" for (you guessed it) backwards compatibility.
  Add documentation update and release note.
........
  r2703 | garyo | 2008-03-25 07:57:01 -0700 (Tue, 25 Mar 2008) | 1 line

  Improve Install error message when target and source list lengths don't match.
........
  r2704 | garyo | 2008-03-25 08:10:24 -0700 (Tue, 25 Mar 2008) | 1 line

  Allow executing main scons.py script without running scons, using standard if __name__==__main__ idiom.
........
  r2705 | stevenknight | 2008-03-26 08:51:58 -0700 (Wed, 26 Mar 2008) | 3 lines

  Update scripts that use {Source,Target}Signatures() to use Decider()
  or the default behavior.  Update test condition checks as necessary.
........
  r2706 | stevenknight | 2008-03-27 14:13:50 -0700 (Thu, 27 Mar 2008) | 2 lines

  Update some leftover uses of env.Copy() in some test scripts to env.Clone().
........
  r2707 | stevenknight | 2008-03-27 14:20:33 -0700 (Thu, 27 Mar 2008) | 6 lines

  Fix use of SetOption('warn') to disable warning messages.
  Refactor the Script.Main._setup_warn() function into
  Warnings.process_warn_strings().
  Split test/option--warn.py into separate test/option/warn-*.py scripts
  for the individual subtests it contained.
........
  r2708 | stevenknight | 2008-03-27 15:17:44 -0700 (Thu, 27 Mar 2008) | 5 lines

  Deprecate the {Target,Source}Signatures() functions and methods.
  Move the test scripts underneath the test/Deprecated directory.
  Update man page with the new --warn=* options (and some that
  were overlooked on previous checkins).  Add a release note.
........
  r2709 | stevenknight | 2008-03-27 23:22:38 -0700 (Thu, 27 Mar 2008) | 2 lines

  More conversion of env.Copy() calls to env.Clone().
........
  r2710 | stevenknight | 2008-03-28 00:09:40 -0700 (Fri, 28 Mar 2008) | 3 lines

  Test updates for old Python versions (1.5.2) now that we generate a
  warning message about the deprecation.
........
  r2711 | stevenknight | 2008-03-28 22:11:03 -0700 (Fri, 28 Mar 2008) | 3 lines

  Chmod the built packages in build/dist to 0644 so they're publicy readable
  when they're copied over to the snapshot system.
........
  r2712 | stevenknight | 2008-03-28 22:11:54 -0700 (Fri, 28 Mar 2008) | 3 lines

  Issue 1951:  have Copy() preserve file times and mode when copying
  over individual files.  (Leanid Nazdrynau)
........
  r2713 | stevenknight | 2008-03-29 06:49:27 -0700 (Sat, 29 Mar 2008) | 3 lines

  Don't bother checking for equivalent file access times.  Under system
  load it can vary because we do actually access the file.
........
  r2714 | GregNoel | 2008-03-29 17:24:25 -0700 (Sat, 29 Mar 2008) | 1 line

  Fix regression test using Python 1.5.2 on OS X
........
  r2715 | GregNoel | 2008-03-29 20:44:19 -0700 (Sat, 29 Mar 2008) | 1 line

  'Copy' conflicts with 'copy' on case-insensitive file systems
........
  r2716 | stevenknight | 2008-03-29 21:00:13 -0700 (Sat, 29 Mar 2008) | 3 lines

  Capture scripts for downloading and installing different versions of
  Python and SCons.
........
  r2717 | stevenknight | 2008-03-30 08:48:28 -0700 (Sun, 30 Mar 2008) | 3 lines

  Fix a regression in how subst_path() handles lists (like a ListOption)
  in expansions of things like $CPPDEFINES and $CPPPATH.
........
  r2718 | stevenknight | 2008-03-30 10:02:21 -0700 (Sun, 30 Mar 2008) | 6 lines

  User's Guide updates:
  --  Paragraph about deprecated BuildDir().
  --  Updated output using the jar -C option.
  --  Updated default environment Dump().
  --  Updated --debug=stacktrace output.
........
  r2719 | stevenknight | 2008-03-31 00:50:08 -0700 (Mon, 31 Mar 2008) | 2 lines

  Update the branch for 0.98.
........

3 files changed, 104 insertions, 82 deletions

diff --git a/src/engine/SCons/Node/FS.py b/src/engine/SCons/Node/FS.py
index 1a3c010..f73161f 100644
--- a/src/engine/SCons/Node/FS.py
+++ b/src/engine/SCons/Node/FS.py
@@ -73,10 +73,10 @@ default_max_drift = 2*24*60*60
 #
 # A number of the above factors, however, can be set after we've already
 # been asked to return a string for a Node, because a Repository() or
-# BuildDir() call or the like may not occur until later in SConscript
+# VariantDir() call or the like may not occur until later in SConscript
 # files.  So this variable controls whether we bother trying to save
 # string values for Nodes.  The wrapper interface can set this whenever
-# they're done mucking with Repository and BuildDir and the other stuff,
+# they're done mucking with Repository and VariantDir and the other stuff,
 # to let this module know it can start returning saved string values
 # for Nodes.
 #
@@ -445,7 +445,7 @@ class EntryProxy(SCons.Util.Proxy):
 
     def __get_srcdir(self):
         """Returns the directory containing the source node linked to this
-        node via BuildDir(), or the directory of this node if not linked."""
+        node via VariantDir(), or the directory of this node if not linked."""
         return EntryProxy(self.get().srcnode().dir)
 
     def __get_rsrcnode(self):
@@ -453,7 +453,7 @@ class EntryProxy(SCons.Util.Proxy):
 
     def __get_rsrcdir(self):
         """Returns the directory containing the source node linked to this
-        node via BuildDir(), or the directory of this node if not linked."""
+        node via VariantDir(), or the directory of this node if not linked."""
         return EntryProxy(self.get().srcnode().rfile().dir)
 
     def __get_dir(self):
@@ -1197,21 +1197,21 @@ class FS(LocalFS):
         """
         return self._lookup(name, directory, Dir, create)
 
-    def BuildDir(self, build_dir, src_dir, duplicate=1):
-        """Link the supplied build directory to the source directory
+    def VariantDir(self, variant_dir, src_dir, duplicate=1):
+        """Link the supplied variant directory to the source directory
         for purposes of building files."""
 
         if not isinstance(src_dir, SCons.Node.Node):
             src_dir = self.Dir(src_dir)
-        if not isinstance(build_dir, SCons.Node.Node):
-            build_dir = self.Dir(build_dir)
-        if src_dir.is_under(build_dir):
-            raise SCons.Errors.UserError, "Source directory cannot be under build directory."
-        if build_dir.srcdir:
-            if build_dir.srcdir == src_dir:
+        if not isinstance(variant_dir, SCons.Node.Node):
+            variant_dir = self.Dir(variant_dir)
+        if src_dir.is_under(variant_dir):
+            raise SCons.Errors.UserError, "Source directory cannot be under variant directory."
+        if variant_dir.srcdir:
+            if variant_dir.srcdir == src_dir:
                 return # We already did this.
-            raise SCons.Errors.UserError, "'%s' already has a source directory: '%s'."%(build_dir, build_dir.srcdir)
-        build_dir.link(src_dir, duplicate)
+            raise SCons.Errors.UserError, "'%s' already has a source directory: '%s'."%(variant_dir, variant_dir.srcdir)
+        variant_dir.link(src_dir, duplicate)
 
     def Repository(self, *dirs):
         """Specify Repository directories to search."""
@@ -1220,11 +1220,11 @@ class FS(LocalFS):
                 d = self.Dir(d)
             self.Top.addRepository(d)
 
-    def build_dir_target_climb(self, orig, dir, tail):
-        """Create targets in corresponding build directories
+    def variant_dir_target_climb(self, orig, dir, tail):
+        """Create targets in corresponding variant directories
 
         Climb the directory tree, and look up path names
-        relative to any linked build directories we find.
+        relative to any linked variant directories we find.
 
         Even though this loops and walks up the tree, we don't memoize
         the return value because this is really only used to process
@@ -1232,10 +1232,10 @@ class FS(LocalFS):
         """
         targets = []
         message = None
-        fmt = "building associated BuildDir targets: %s"
+        fmt = "building associated VariantDir targets: %s"
         start_dir = dir
         while dir:
-            for bd in dir.build_dirs:
+            for bd in dir.variant_dirs:
                 if start_dir.is_under(bd):
                     # If already in the build-dir location, don't reflect
                     return [orig], fmt % str(orig)
@@ -1314,7 +1314,7 @@ class Dir(Base):
         self.cwd = self
         self.searched = 0
         self._sconsign = None
-        self.build_dirs = []
+        self.variant_dirs = []
         self.root = self.dir.root
 
         # Don't just reset the executor, replace its action list,
@@ -1385,16 +1385,16 @@ class Dir(Base):
         a path containing '..'), an absolute path name, a top-relative
         ('#foo') path name, or any kind of object.
         """
-        name = self.labspath + '/' + name
+        name = self.entry_labspath(name)
         return self.root._lookup_abs(name, klass, create)
 
     def link(self, srcdir, duplicate):
-        """Set this directory as the build directory for the
+        """Set this directory as the variant directory for the
         supplied source directory."""
         self.srcdir = srcdir
         self.duplicate = duplicate
         self.__clearRepositoryCache(duplicate)
-        srcdir.build_dirs.append(self)
+        srcdir.variant_dirs.append(self)
 
     def getRepositories(self):
         """Returns a list of repositories for this directory.
@@ -1580,9 +1580,9 @@ class Dir(Base):
         return not self.builder is MkdirBuilder and self.has_builder()
 
     def alter_targets(self):
-        """Return any corresponding targets in a build directory.
+        """Return any corresponding targets in a variant directory.
         """
-        return self.fs.build_dir_target_climb(self, self, [])
+        return self.fs.variant_dir_target_climb(self, self, [])
 
     def scanner_key(self):
         """A directory does not get scanned."""
@@ -1696,7 +1696,7 @@ class Dir(Base):
         for dir in self.srcdir_list():
             if self.is_under(dir):
                 # We shouldn't source from something in the build path;
-                # build_dir is probably under src_dir, in which case
+                # variant_dir is probably under src_dir, in which case
                 # we are reflecting.
                 break
             if dir.entry_exists_on_disk(name):
@@ -1823,8 +1823,8 @@ class Dir(Base):
 
         The "source" argument, when true, specifies that corresponding
         source Nodes must be returned if you're globbing in a build
-        directory (initialized with BuildDir()).  The default behavior
-        is to return Nodes local to the BuildDir().
+        directory (initialized with VariantDir()).  The default behavior
+        is to return Nodes local to the VariantDir().
 
         The "strings" argument, when true, returns the matches as strings,
         not Nodes.  The strings are path names relative to this directory.
@@ -1940,7 +1940,7 @@ class RootDir(Dir):
         # except for the "lookup abspath," which does not have the
         # drive letter.
         self.abspath = name + os.sep
-        self.labspath = '/'
+        self.labspath = ''
         self.path = name + os.sep
         self.tpath = name + os.sep
         self._morph()
@@ -1951,6 +1951,7 @@ class RootDir(Dir):
         # os.path.normpath() seems to preserve double slashes at the
         # beginning of a path (presumably for UNC path names), but
         # collapses triple slashes to a single slash.
+        self._lookupDict[''] = self
         self._lookupDict['/'] = self
         self._lookupDict['//'] = self
         self._lookupDict[os.sep] = self
@@ -2008,7 +2009,7 @@ class RootDir(Dir):
         return self.abspath + name
 
     def entry_labspath(self, name):
-        return self.labspath + name
+        return '/' + name
 
     def entry_path(self, name):
         return self.path + name
@@ -2525,11 +2526,11 @@ class File(Base):
         return not scb is None
 
     def alter_targets(self):
-        """Return any corresponding targets in a build directory.
+        """Return any corresponding targets in a variant directory.
         """
         if self.is_derived():
             return [], None
-        return self.fs.build_dir_target_climb(self, self.dir, [self.name])
+        return self.fs.variant_dir_target_climb(self, self.dir, [self.name])
 
     def _rmv_existing(self):
         self.clear_memoized_values()
@@ -2596,7 +2597,7 @@ class File(Base):
         if self.duplicate and not self.is_derived() and not self.linked:
             src = self.srcnode()
             if not src is self:
-                # At this point, src is meant to be copied in a build directory.
+                # At this point, src is meant to be copied in a variant directory.
                 src = src.rfile()
                 if src.abspath != self.abspath:
                     if src.exists():
@@ -2605,7 +2606,7 @@ class File(Base):
                         # 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 build directory.
+                        # copy remains in the variant directory.
                         if Base.exists(self) or self.islink():
                             self.fs.unlink(self.path)
                         # Return None explicitly because the Base.exists() call
diff --git a/src/engine/SCons/Node/FSTests.py b/src/engine/SCons/Node/FSTests.py
index b698e87..cfdc978 100644
--- a/src/engine/SCons/Node/FSTests.py
+++ b/src/engine/SCons/Node/FSTests.py
@@ -123,14 +123,14 @@ class _tempdirTestCase(unittest.TestCase):
     def tearDown(self):
         os.chdir(self.save_cwd)
 
-class BuildDirTestCase(unittest.TestCase):
+class VariantDirTestCase(unittest.TestCase):
     def runTest(self):
-        """Test build dir functionality"""
+        """Test variant dir functionality"""
         test=TestCmd(workdir='')
 
         fs = SCons.Node.FS.FS()
         f1 = fs.File('build/test1')
-        fs.BuildDir('build', 'src')
+        fs.VariantDir('build', 'src')
         f2 = fs.File('build/test2')
         d1 = fs.Dir('build')
         assert f1.srcnode().path == os.path.normpath('src/test1'), f1.srcnode().path
@@ -139,7 +139,7 @@ class BuildDirTestCase(unittest.TestCase):
 
         fs = SCons.Node.FS.FS()
         f1 = fs.File('build/test1')
-        fs.BuildDir('build', '.')
+        fs.VariantDir('build', '.')
         f2 = fs.File('build/test2')
         d1 = fs.Dir('build')
         assert f1.srcnode().path == 'test1', f1.srcnode().path
@@ -147,16 +147,16 @@ class BuildDirTestCase(unittest.TestCase):
         assert d1.srcnode().path == '.', d1.srcnode().path
 
         fs = SCons.Node.FS.FS()
-        fs.BuildDir('build/var1', 'src')
-        fs.BuildDir('build/var2', 'src')
+        fs.VariantDir('build/var1', 'src')
+        fs.VariantDir('build/var2', 'src')
         f1 = fs.File('build/var1/test1')
         f2 = fs.File('build/var2/test1')
         assert f1.srcnode().path == os.path.normpath('src/test1'), f1.srcnode().path
         assert f2.srcnode().path == os.path.normpath('src/test1'), f2.srcnode().path
 
         fs = SCons.Node.FS.FS()
-        fs.BuildDir('../var1', 'src')
-        fs.BuildDir('../var2', 'src')
+        fs.VariantDir('../var1', 'src')
+        fs.VariantDir('../var2', 'src')
         f1 = fs.File('../var1/test1')
         f2 = fs.File('../var2/test1')
         assert f1.srcnode().path == os.path.normpath('src/test1'), f1.srcnode().path
@@ -180,11 +180,11 @@ class BuildDirTestCase(unittest.TestCase):
         # A source file in the repository
         test.write([ 'rep1', 'src', 'test2.in' ], 'test2.in')
 
-        # Some source files in the build directory
+        # Some source files in the variant directory
         test.write([ 'work', 'build', 'var2', 'test.in' ], 'test.old')
         test.write([ 'work', 'build', 'var2', 'test2.in' ], 'test2.old')
 
-        # An old derived file in the build directories
+        # An old derived file in the variant directories
         test.write([ 'work', 'build', 'var1', 'test.out' ], 'test.old')
         test.write([ 'work', 'build', 'var2', 'test.out' ], 'test.old')
 
@@ -199,8 +199,8 @@ class BuildDirTestCase(unittest.TestCase):
         os.chdir(test.workpath('work'))
 
         fs = SCons.Node.FS.FS(test.workpath('work'))
-        fs.BuildDir('build/var1', 'src', duplicate=0)
-        fs.BuildDir('build/var2', 'src')
+        fs.VariantDir('build/var1', 'src', duplicate=0)
+        fs.VariantDir('build/var2', 'src')
         f1 = fs.File('build/var1/test.in')
         f1out = fs.File('build/var1/test.out')
         f1out.builder = 1
@@ -356,7 +356,7 @@ class BuildDirTestCase(unittest.TestCase):
         assert bdt == [var1_new_dir, var2_new_dir], bdt
 
         # Test that an IOError trying to Link a src file
-        # into a BuildDir ends up throwing a StopError.
+        # into a VariantDir ends up throwing a StopError.
         fIO = fs.File("build/var2/IOError")
 
         save_Link = SCons.Node.FS.Link
@@ -392,13 +392,13 @@ class BuildDirTestCase(unittest.TestCase):
         # This used to generate a UserError when we forbid the source
         # directory from being outside the top-level SConstruct dir.
         fs = SCons.Node.FS.FS()
-        fs.BuildDir('build', '/test/foo')
+        fs.VariantDir('build', '/test/foo')
 
         exc_caught = 0
         try:
             try:
                 fs = SCons.Node.FS.FS()
-                fs.BuildDir('build', 'build/src')
+                fs.VariantDir('build', 'build/src')
             except SCons.Errors.UserError:
                 exc_caught = 1
             assert exc_caught, "Should have caught a UserError."
@@ -407,25 +407,25 @@ class BuildDirTestCase(unittest.TestCase):
             test.unlink( "build/foo" )
 
         fs = SCons.Node.FS.FS()
-        fs.BuildDir('build', 'src1')
+        fs.VariantDir('build', 'src1')
 
-        # Calling the same BuildDir twice should work fine.
-        fs.BuildDir('build', 'src1')
+        # Calling the same VariantDir twice should work fine.
+        fs.VariantDir('build', 'src1')
 
-        # Trying to move a build dir to a second source dir
+        # Trying to move a variant dir to a second source dir
         # should blow up
         try:
-            fs.BuildDir('build', 'src2')
+            fs.VariantDir('build', 'src2')
         except SCons.Errors.UserError:
             pass
         else:
             assert 0, "Should have caught a UserError."
 
         # Test against a former bug.  Make sure we can get a repository
-        # path for the build directory itself!
+        # path for the variant directory itself!
         fs=SCons.Node.FS.FS(test.workpath('work'))
         test.subdir('work')
-        fs.BuildDir('build/var3', 'src', duplicate=0)
+        fs.VariantDir('build/var3', 'src', duplicate=0)
         d1 = fs.Dir('build/var3')
         r = d1.rdir()
         assert r == d1, "%s != %s" % (r, d1)
@@ -524,10 +524,10 @@ class BuildDirTestCase(unittest.TestCase):
                     delattr(os, 'symlink')
                 shutil.copy2 = real_copy
 
-        # Test BuildDir "reflection," where a same-named subdirectory
-        # exists underneath a build_dir.
+        # Test VariantDir "reflection," where a same-named subdirectory
+        # exists underneath a variant_dir.
         fs = SCons.Node.FS.FS()
-        fs.BuildDir('work/src/b1/b2', 'work/src')
+        fs.VariantDir('work/src/b1/b2', 'work/src')
 
         dir_list = [
                 'work/src',
@@ -1737,8 +1737,8 @@ class DirTestCase(_tempdirTestCase):
         sub1 = bld.Dir('sub')
         sub2 = sub1.Dir('sub')
         sub3 = sub2.Dir('sub')
-        self.fs.BuildDir(bld, src, duplicate=0)
-        self.fs.BuildDir(sub2, src, duplicate=0)
+        self.fs.VariantDir(bld, src, duplicate=0)
+        self.fs.VariantDir(sub2, src, duplicate=0)
 
         def check(result, expect):
             result = map(str, result)
@@ -1760,7 +1760,7 @@ class DirTestCase(_tempdirTestCase):
         s = sub3.srcdir_list()
         check(s, ['src/sub', 'src/sub/sub/sub'])
 
-        self.fs.BuildDir('src/b1/b2', 'src')
+        self.fs.VariantDir('src/b1/b2', 'src')
         b1 = src.Dir('b1')
         b1_b2 = b1.Dir('b2')
         b1_b2_b1 = b1_b2.Dir('b1')
@@ -1792,7 +1792,7 @@ class DirTestCase(_tempdirTestCase):
 
         bld0 = self.fs.Dir('bld0')
         src0 = self.fs.Dir('src0')
-        self.fs.BuildDir(bld0, src0, duplicate=0)
+        self.fs.VariantDir(bld0, src0, duplicate=0)
 
         n = bld0.srcdir_duplicate('does_not_exist')
         assert n is None, n
@@ -1807,7 +1807,7 @@ class DirTestCase(_tempdirTestCase):
 
         bld1 = self.fs.Dir('bld1')
         src1 = self.fs.Dir('src1')
-        self.fs.BuildDir(bld1, src1, duplicate=1)
+        self.fs.VariantDir(bld1, src1, duplicate=1)
 
         n = bld1.srcdir_duplicate('does_not_exist')
         assert n is None, n
@@ -1832,7 +1832,7 @@ class DirTestCase(_tempdirTestCase):
 
         bld0 = self.fs.Dir('bld0')
         src0 = self.fs.Dir('src0')
-        self.fs.BuildDir(bld0, src0, duplicate=0)
+        self.fs.VariantDir(bld0, src0, duplicate=0)
 
         derived_f = src0.File('derived-f')
         derived_f.is_derived = return_true
@@ -1867,7 +1867,7 @@ class DirTestCase(_tempdirTestCase):
         n = src0.srcdir_find_file('on-disk-e1')
         check(n, ['src0/on-disk-e1', 'src0'])
 
-        # Now check from the build directory.
+        # Now check from the variant directory.
         n = bld0.srcdir_find_file('does_not_exist')
         assert n == (None, None), n
 
@@ -1893,7 +1893,7 @@ class DirTestCase(_tempdirTestCase):
 
         bld1 = self.fs.Dir('bld1')
         src1 = self.fs.Dir('src1')
-        self.fs.BuildDir(bld1, src1, duplicate=1)
+        self.fs.VariantDir(bld1, src1, duplicate=1)
 
         derived_f = src1.File('derived-f')
         derived_f.is_derived = return_true
@@ -1923,7 +1923,7 @@ class DirTestCase(_tempdirTestCase):
         n = src1.srcdir_find_file('on-disk-e1')
         check(n, ['src1/on-disk-e1', 'src1'])
 
-        # Now check from the build directory.
+        # Now check from the variant directory.
         n = bld1.srcdir_find_file('does_not_exist')
         assert n == (None, None), n
 
@@ -2069,7 +2069,7 @@ class FileTestCase(_tempdirTestCase):
         assert src_f1.exists(), "%s apparently does not exist?" % src_f1
 
         test.subdir('build')
-        fs.BuildDir('build', 'src')
+        fs.VariantDir('build', 'src')
         build_f1 = fs.File('build/f1')
 
         assert build_f1.exists(), "%s did not realize that %s exists" % (build_f1, src_f1)
@@ -2638,7 +2638,7 @@ class RepositoryTestCase(_tempdirTestCase):
         test.write([self.rep2, "i_exist"], "\n")
         test.write(["work", "i_exist_too"], "\n")
 
-        fs.BuildDir('build', '.')
+        fs.VariantDir('build', '.')
 
         f = fs.File(test.workpath("work", "i_do_not_exist"))
         assert not f.rexists()
@@ -3023,7 +3023,7 @@ class disambiguateTestCase(unittest.TestCase):
         test.subdir(['src', 'edir'])
         test.write(['src', 'efile'], "src/efile\n")
 
-        fs.BuildDir(test.workpath('build'), test.workpath('src'))
+        fs.VariantDir(test.workpath('build'), test.workpath('src'))
 
         build_bdir = fs.Entry(test.workpath('build/bdir'))
         d = build_bdir.disambiguate()
@@ -3141,8 +3141,8 @@ class SpecialAttrTestCase(unittest.TestCase):
         s = str(f.srcpath.win32)
         assert s == 'foo\\bar\\baz.blat', s
 
-        # Test what happens with BuildDir()
-        fs.BuildDir('foo', 'baz')
+        # Test what happens with VariantDir()
+        fs.VariantDir('foo', 'baz')
 
         s = str(f.srcpath)
         assert s == os.path.normpath('baz/bar/baz.blat'), s
@@ -3156,7 +3156,7 @@ class SpecialAttrTestCase(unittest.TestCase):
         g = f.srcdir.get()
         assert isinstance(g, SCons.Node.FS.Dir), g.__class__
 
-        # And now what happens with BuildDir() + Repository()
+        # And now what happens with VariantDir() + Repository()
         fs.Repository(test.workpath('repository'))
 
         f = fs.Entry('foo/sub/file.suffix').get_subst_proxy()
@@ -3250,8 +3250,8 @@ class SaveStringsTestCase(unittest.TestCase):
 
         fs1 = SCons.Node.FS.FS(test.workpath('fs1'))
         nodes = setup(fs1)
-        fs1.BuildDir('d0', 'src', duplicate=0)
-        fs1.BuildDir('d1', 'src', duplicate=1)
+        fs1.VariantDir('d0', 'src', duplicate=0)
+        fs1.VariantDir('d1', 'src', duplicate=1)
 
         s = map(str, nodes)
         expect = map(os.path.normpath, ['src/f', 'd1/f', 'd0/b', 'd1/b'])
@@ -3266,8 +3266,8 @@ class SaveStringsTestCase(unittest.TestCase):
         SCons.Node.FS.save_strings(1)
         fs2 = SCons.Node.FS.FS(test.workpath('fs2'))
         nodes = setup(fs2)
-        fs2.BuildDir('d0', 'src', duplicate=0)
-        fs2.BuildDir('d1', 'src', duplicate=1)
+        fs2.VariantDir('d0', 'src', duplicate=0)
+        fs2.VariantDir('d1', 'src', duplicate=1)
 
         s = map(str, nodes)
         expect = map(os.path.normpath, ['src/f', 'd1/f', 'd0/b', 'd1/b'])
@@ -3280,10 +3280,27 @@ class SaveStringsTestCase(unittest.TestCase):
         assert s == expect, 'node str() not cached: %s'%s
 
 
+class AbsolutePathTestCase(unittest.TestCase):
+    def test_root_lookup_equivalence(self):
+        """Test looking up /fff vs. fff in the / directory"""
+        test=TestCmd(workdir='')
+
+        fs = SCons.Node.FS.FS('/')
+
+        save_cwd = os.getcwd()
+        try:
+            os.chdir('/')
+            fff1 = fs.File('fff')
+            fff2 = fs.File('/fff')
+            assert fff1 is fff2, "fff and /fff returned different Nodes!"
+        finally:
+            os.chdir(save_cwd)
+
+
 
 if __name__ == "__main__":
     suite = unittest.TestSuite()
-    suite.addTest(BuildDirTestCase())
+    suite.addTest(VariantDirTestCase())
     suite.addTest(find_fileTestCase())
     suite.addTest(StringDirTestCase())
     suite.addTest(stored_infoTestCase())
@@ -3296,6 +3313,7 @@ if __name__ == "__main__":
     suite.addTest(SpecialAttrTestCase())
     suite.addTest(SaveStringsTestCase())
     tclasses = [
+        AbsolutePathTestCase,
         BaseTestCase,
         CacheDirTestCase,
         DirTestCase,
diff --git a/src/engine/SCons/Node/__init__.py b/src/engine/SCons/Node/__init__.py
index 4ca34e0..2e136f0 100644
--- a/src/engine/SCons/Node/__init__.py
+++ b/src/engine/SCons/Node/__init__.py
@@ -225,7 +225,7 @@ class Node:
         self.attributes = self.Attrs() # Generic place to stick information about the Node.
         self.side_effect = 0 # true iff this node is a side effect
         self.side_effects = [] # the side effects of building this target
-        self.linked = 0 # is this node linked to the build directory?
+        self.linked = 0 # is this node linked to the variant directory?
 
         self.clear_memoized_values()
 
@@ -505,7 +505,7 @@ class Node:
         Returns true iff this node is derived (i.e. built).
 
         This should return true only for nodes whose path should be in
-        the build directory when duplicate=0 and should contribute their build
+        the variant directory when duplicate=0 and should contribute their build
         signatures when they are used as source files to other derived files. For
         example: source with source builders are not derived in this sense,
         and hence should not return true.
@@ -1161,7 +1161,10 @@ class Node:
         # so we only print them after running them through this lambda
         # to turn them into the right relative Node and then return
         # its string.
-        stringify = lambda s, E=self.dir.Entry: str(E(s))
+        def stringify( s, E=self.dir.Entry ) :
+            if hasattr( s, 'dir' ) :
+                return str(E(s))
+            return str(s)
 
         lines = []