Add duplicate (defaults to true) option to BuildDir()

5 files changed, 91 insertions, 49 deletions

diff --git a/src/engine/SCons/Node/FS.py b/src/engine/SCons/Node/FS.py
index adfd440..98b6b02 100644
--- a/src/engine/SCons/Node/FS.py
+++ b/src/engine/SCons/Node/FS.py
@@ -279,18 +279,20 @@ class FS:
         name, directory = self.__transformPath(name, directory)
         return self.__doLookup(Dir, name, directory)
 
-    def BuildDir(self, build_dir, src_dir):
+    def BuildDir(self, build_dir, src_dir, duplicate=1):
         """Link the supplied build directory to the source directory
         for purposes of building files."""
         self.__setTopLevelDir()
-        dirSrc = self.Dir(src_dir)
-        dirBuild = self.Dir(build_dir)
-        if not dirSrc.is_under(self.Top) or not dirBuild.is_under(self.Top):
+        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)
+        build_dir.duplicate = duplicate
+        if not src_dir.is_under(self.Top) or not build_dir.is_under(self.Top):
             raise UserError, "Both source and build directories must be under top of build tree."
-        if dirSrc.is_under(dirBuild):
+        if src_dir.is_under(build_dir):
             raise UserError, "Source directory cannot be under build directory."
-        dirBuild.link(dirSrc)
-        
+        build_dir.link(src_dir, duplicate)
 
 class Entry(SCons.Node.Node):
     """A generic class for file system entries.  This class if for
@@ -309,6 +311,7 @@ class Entry(SCons.Node.Node):
 
         self.name = name
         if directory:
+            self.duplicate = directory.duplicate
             self.abspath = os.path.join(directory.abspath, name)
             if str(directory.path) == '.':
                 self.path = name
@@ -316,16 +319,18 @@ class Entry(SCons.Node.Node):
                 self.path = os.path.join(directory.path, name)
         else:
             self.abspath = self.path = name
+            self.duplicate = 1
         self.path_ = self.path
         self.abspath_ = self.abspath
         self.dir = directory
 	self.use_signature = 1
-        self.__doSrcpath()
+        self.__doSrcpath(self.duplicate)
 
-    def adjust_srcpath(self):
-        self.__doSrcpath()
+    def adjust_srcpath(self, duplicate):
+        self.__doSrcpath(duplicate)
         
-    def __doSrcpath(self):
+    def __doSrcpath(self, duplicate):
+        self.duplicate = duplicate
         if self.dir:
             if str(self.dir.srcpath) == '.':
                 self.srcpath = self.name
@@ -336,7 +341,10 @@ class Entry(SCons.Node.Node):
 
     def __str__(self):
 	"""A FS node's string representation is its path name."""
-	return self.path
+        if self.duplicate or self.builder:
+            return self.path
+        else:
+            return self.srcpath
 
     def __cmp__(self, other):
 	if type(self) != types.StringType and type(other) != types.StringType:
@@ -351,7 +359,7 @@ class Entry(SCons.Node.Node):
 	return hash(self.abspath_)
 
     def exists(self):
-        return os.path.exists(self.abspath)
+        return os.path.exists(str(self))
 
     def current(self):
         """If the underlying path doesn't exist, we know the node is
@@ -411,20 +419,20 @@ class Dir(Entry):
         self.builder = 1
         self._sconsign = None
 
-    def __doReparent(self):
+    def __doReparent(self, duplicate):
         for ent in self.entries.values():
             if not ent is self and not ent is self.dir:
-                ent.adjust_srcpath()
+                ent.adjust_srcpath(duplicate)
 
-    def adjust_srcpath(self):
-        Entry.adjust_srcpath(self)
-        self.__doReparent()
+    def adjust_srcpath(self, duplicate):
+        Entry.adjust_srcpath(self, duplicate)
+        self.__doReparent(duplicate)
                 
-    def link(self, srcdir):
+    def link(self, srcdir, duplicate):
         """Set this directory as the build directory for the
         supplied source directory."""
         self.srcpath = srcdir.path
-        self.__doReparent()
+        self.__doReparent(duplicate)
 
     def up(self):
         return self.entries['..']
@@ -526,7 +534,7 @@ class File(Entry):
 
     def get_timestamp(self):
         if self.exists():
-            return os.path.getmtime(self.path)
+            return os.path.getmtime(str(self))
         else:
             return 0
 
@@ -556,12 +564,12 @@ class File(Entry):
         if self.env:
             for scn in self.scanners:
                 if not self.scanned.has_key(scn):
-                    self.add_implicit(scn.scan(self.path, self.env),
-                                      scn)
+                    deps = scn.scan(str(self), self.env)
+                    self.add_implicit(deps,scn)
                     self.scanned[scn] = 1
                     
     def exists(self):
-        if not self.created:
+        if self.duplicate and not self.created:
             self.created = 1
             if self.srcpath != self.path and \
                os.path.exists(self.srcpath):
diff --git a/src/engine/SCons/Node/FSTests.py b/src/engine/SCons/Node/FSTests.py
index f2130d7..4801dae 100644
--- a/src/engine/SCons/Node/FSTests.py
+++ b/src/engine/SCons/Node/FSTests.py
@@ -86,6 +86,20 @@ class BuildDirTestCase(unittest.TestCase):
         assert f1.srcpath == os.path.normpath('src/test1'), f1.srcpath
         assert f2.srcpath == os.path.normpath('src/test1'), f2.srcpath
 
+        fs = SCons.Node.FS.FS()
+        fs.BuildDir('build/var1', 'src', duplicate=0)
+        fs.BuildDir('build/var2', 'src')
+        f1 = fs.File('build/var1/test1')
+        f1out = fs.File('build/var1/test1.out')
+        f1out.builder = 1
+        f2 = fs.File('build/var2/test1')
+        assert f1.srcpath == os.path.normpath('src/test1'), f1.srcpath
+        assert f1out.srcpath == os.path.normpath('src/test1.out'), f1out.srcpath
+        assert str(f1) == os.path.normpath('src/test1'), str(f1)
+        assert str(f1out) == os.path.normpath('build/var1/test1.out'), str(f1out)
+        assert f2.srcpath == os.path.normpath('src/test1'), str(f2)
+        assert str(f2) == os.path.normpath('build/var2/test1'), str(f2)
+
         # Test to see if file_link() works...
         test=TestCmd(workdir='')
         test.subdir('src','build')
diff --git a/src/engine/SCons/Script/SConscript.py b/src/engine/SCons/Script/SConscript.py
index 924fd29..7085547 100644
--- a/src/engine/SCons/Script/SConscript.py
+++ b/src/engine/SCons/Script/SConscript.py
@@ -89,22 +89,23 @@ def SConscript(script, exports=[]):
     # push:
     stack.append(Frame(exports))
 
-    # call:
-    if script == "-":
-        exec sys.stdin in stack[-1].globals
-    else:
-        f = SCons.Node.FS.default_fs.File(script)
-        if f.exists():
-            file = open(str(f), "r")
-            SCons.Node.FS.default_fs.chdir(f.dir)
-            exec file in stack[-1].globals
+    try:
+        # call:
+        if script == "-":
+            exec sys.stdin in stack[-1].globals
         else:
-            sys.stderr.write("Ignoring missing SConscript '%s'\n" % f.path)
-    
-
-    # pop:
-    frame = stack.pop()
-    SCons.Node.FS.default_fs.chdir(frame.prev_dir)
+            if not isinstance(script, SCons.Node.Node):
+                script = SCons.Node.FS.default_fs.File(script)
+            if script.exists():
+                file = open(str(script), "r")
+                SCons.Node.FS.default_fs.chdir(script.dir)
+                exec file in stack[-1].globals
+            else:
+                sys.stderr.write("Ignoring missing SConscript '%s'\n" % script.path)
+    finally:
+        # pop:
+        frame = stack.pop()
+        SCons.Node.FS.default_fs.chdir(frame.prev_dir)
     
     return frame.retval
     
@@ -122,8 +123,8 @@ def Help(text):
         print "Use scons -H for help about command-line options."
         sys.exit(0)
 
-def BuildDir(build_dir, src_dir):
-    SCons.Node.FS.default_fs.BuildDir(build_dir, src_dir)
+def BuildDir(build_dir, src_dir, duplicate=1):
+    SCons.Node.FS.default_fs.BuildDir(build_dir, src_dir, duplicate)
 
 def GetBuildPath(files):
     nodes = SCons.Util.scons_str2nodes(files,
@@ -173,4 +174,6 @@ def BuildDefaultGlobals():
     globals['Export'] = Export
     globals['Import'] = Import
     globals['Return'] = Return
+    globals['Dir'] = SCons.Node.FS.default_fs.Dir
+    globals['File'] = SCons.Node.FS.default_fs.File
     return globals
diff --git a/src/engine/SCons/Util.py b/src/engine/SCons/Util.py
index 0d05498..262762e 100644
--- a/src/engine/SCons/Util.py
+++ b/src/engine/SCons/Util.py
@@ -37,6 +37,7 @@ import re
 from UserList import UserList
 import SCons.Node.FS
 import copy
+import SCons.Node
 
 def scons_str2nodes(arg, node_factory=SCons.Node.FS.default_fs.File):
     """This function converts a string or list into a list of Node instances.
@@ -199,7 +200,7 @@ def scons_subst_list(strSubst, locals, globals):
     n = 1
 
     # Tokenize the original string...
-    strSubst = _space_sep.sub('\0', strSubst)
+    strSubst = _space_sep.sub('\0', str(strSubst))
     
     # Now, do the substitution
     while n != 0:
@@ -266,7 +267,14 @@ class VarInterpolator:
         src = dict[self.src]
         if not type(src) is types.ListType and not isinstance(src, UserList):
             src = [ src ]
-        return map(lambda x, d=dict: scons_subst(x, {}, d), src)
+
+        def prepare(x, dict=dict):
+            if isinstance(x, SCons.Node.Node):
+                return x
+            else:
+                return scons_subst(x, {}, dict)
+
+        return map(prepare, src)
 
     def generate(self, dict):
         if not dict.has_key(self.src):
@@ -300,9 +308,14 @@ class DirVarInterp(VarInterpolator):
         
     def prepareSrc(self, dict):
         src = VarInterpolator.prepareSrc(self, dict)
-        return map(lambda x, fs=self.fs, d=self.dir: \
-                   fs.Dir(str(x), directory = d).path,
-                   src)
+	
+	def prepare(x, self=self):
+	    if not isinstance(x, SCons.Node.Node):
+		return self.fs.Dir(str(x), directory=self.dir)
+	    else:
+		return x
+	    
+        return map(prepare, src)
 
     def instance(self, dir, fs):
         try:
diff --git a/src/engine/SCons/UtilTests.py b/src/engine/SCons/UtilTests.py
index 9eebc85..a7c9e70 100644
--- a/src/engine/SCons/UtilTests.py
+++ b/src/engine/SCons/UtilTests.py
@@ -165,9 +165,10 @@ class UtilTestCase(unittest.TestCase):
         test = TestCmd.TestCmd(workdir = '')
         test.write('./foo', 'Some file\n')
         fs = SCons.Node.FS.FS(test.workpath(""))
+        os.chdir(test.workpath("")) # FS doesn't like the cwd to be something other than it's root
         node_derived = fs.File(test.workpath('./bar/baz'))
         node_derived.builder_set(1) # Any non-zero value.
-        paths = map(lambda x, fs=fs: fs.Dir(x), ['.', './bar'])
+        paths = map(fs.Dir, ['.', './bar'])
         nodes = find_files(['foo', 'baz'], paths, fs.File)
         file_names = map(str, nodes)
         file_names = map(os.path.normpath, file_names)
@@ -188,12 +189,13 @@ class UtilTestCase(unittest.TestCase):
         assert dict['_LIBFLAGS'][2] == 'foobazbar', \
                dict['_LIBFLAGS'][2]
 
-        dict = {'CPPPATH'   : [ 'foo', 'bar', 'baz', '$FOO/bar' ],
+        blat = SCons.Node.FS.default_fs.File('blat')
+        dict = {'CPPPATH'   : [ 'foo', 'bar', 'baz', '$FOO/bar', blat],
                 'INCPREFIX' : 'foo',
                 'INCSUFFIX' : 'bar',
                 'FOO'       : 'baz' }
         autogenerate(dict, dir = SCons.Node.FS.default_fs.Dir('/xx'))
-        assert len(dict['_INCFLAGS']) == 4, dict['_INCFLAGS']
+        assert len(dict['_INCFLAGS']) == 5, dict['_INCFLAGS']
         assert dict['_INCFLAGS'][0] == os.path.normpath('foo/xx/foobar'), \
                dict['_INCFLAGS'][0]
         assert dict['_INCFLAGS'][1] == os.path.normpath('foo/xx/barbar'), \
@@ -203,6 +205,8 @@ class UtilTestCase(unittest.TestCase):
         assert dict['_INCFLAGS'][3] == os.path.normpath('foo/xx/baz/barbar'), \
                dict['_INCFLAGS'][3]
         
+        assert dict['_INCFLAGS'][4] == os.path.normpath('fooblatbar'), \
+               dict['_INCFLAGS'][4]
         
 if __name__ == "__main__":
     suite = unittest.makeSuite(UtilTestCase, 'test_')