Fix a regression with CPPDEFINES when using the g++ Tool.

7 files changed, 327 insertions, 460 deletions

diff --git a/src/CHANGES.txt b/src/CHANGES.txt
index 61dad1e..f3082b7 100644
--- a/src/CHANGES.txt
+++ b/src/CHANGES.txt
@@ -8,6 +8,14 @@
 
 
 
+RELEASE X.XX - XXX, XX XXX XXXX XX:XX:XX -XXXX
+
+  From Steven Knight:
+
+  - Fix use of CPPDEFINES with C++ source files.
+
+
+
 RELEASE 0.93 - Thu, 23 Oct 2003 07:26:55 -0500
 
   From J.T. Conklin:
diff --git a/src/engine/SCons/Node/FS.py b/src/engine/SCons/Node/FS.py
index cffa2b5..a78a2c9 100644
--- a/src/engine/SCons/Node/FS.py
+++ b/src/engine/SCons/Node/FS.py
@@ -41,7 +41,6 @@ import os.path
 import shutil
 import stat
 import string
-import cStringIO
 
 import SCons.Action
 import SCons.Errors
@@ -721,7 +720,7 @@ class FS:
                 self._cwd = dir
                 if change_os_dir:
                     os.chdir(dir.abspath)
-        except OSError:
+        except:
             self._cwd = curr
             raise
 
@@ -903,17 +902,6 @@ class FS:
             message = "building associated BuildDir targets: %s" % string.join(map(str, targets))
         return targets, message
 
-class DummyExecutor:
-    """Dummy executor class returned by Dir nodes to bamboozle SCons
-    into thinking we are an actual derived node, where our sources are
-    our directory entries."""
-    def get_raw_contents(self):
-        return ''
-    def get_contents(self):
-        return ''
-    def get_timestamp(self):
-        return 0
-
 class Dir(Base):
     """A class for directories in a file system.
     """
@@ -936,14 +924,12 @@ class Dir(Base):
         self.abspath_ = self.abspath + os.sep
         self.repositories = []
         self.srcdir = None
-        self.source_scanner = None
         
         self.entries = {}
         self.entries['.'] = self
         self.entries['..'] = self.dir
         self.cwd = self
         self.builder = 1
-        self.searched = 0
         self._sconsign = None
         self.build_dirs = []
 
@@ -1037,19 +1023,6 @@ class Dir(Base):
                              self.all_children(scan))
 
     def all_children(self, scan=1):
-        # Before we traverse our children, make sure we have created Nodes
-        # for any files that this directory contains.  We need to do this
-        # so any change in a file in this directory will cause it to
-        # be out of date.
-        if not self.searched:
-            try:
-                for filename in os.listdir(self.abspath):
-                    if filename != '.sconsign':
-                        self.Entry(filename)
-            except OSError:
-                # Directory does not exist.  No big deal
-                pass
-            self.searched = 1
         keys = filter(lambda k: k != '.' and k != '..', self.entries.keys())
         kids = map(lambda x, s=self: s.entries[x], keys)
         def c(one, two):
@@ -1078,6 +1051,10 @@ class Dir(Base):
         """A directory does not get scanned."""
         return None
 
+    def calc_signature(self, calc):
+        """A directory has no signature."""
+        return None
+
     def set_bsig(self, bsig):
         """A directory has no signature."""
         bsig = None
@@ -1087,12 +1064,9 @@ class Dir(Base):
         csig = None
 
     def get_contents(self):
-        """Return aggregate contents of all our children."""
-        contents = cStringIO.StringIO()
-        for kid in self.children(None):
-            contents.write(kid.get_contents())
-        return contents.getvalue()
-    
+        """Return a fixed "contents" value of a directory."""
+        return ''
+
     def prepare(self):
         pass
 
@@ -1136,24 +1110,6 @@ class Dir(Base):
             return self.srcdir
         return Base.srcnode(self)
 
-    def get_executor(self, create=1):
-        """Fetch the action executor for this node.  Create one if
-        there isn't already one, and requested to do so."""
-        try:
-            executor = self.executor
-        except AttributeError:
-            executor = DummyExecutor()
-            self.executor = executor
-        return executor
-
-    def get_timestamp(self):
-        """Return the latest timestamp from among our children"""
-        stamp = 0
-        for kid in self.children(None):
-            if kid.get_timestamp() > stamp:
-                stamp = kid.get_timestamp()
-        return stamp
-
 class File(Base):
     """A class for files in a file system.
     """
@@ -1476,7 +1432,7 @@ class File(Base):
     def rfile(self):
         try:
             return self._rfile
-        except AttributeError:
+        except:
             self._rfile = self
             if not self.exists():
                 n = self.fs.Rsearch(self.path, clazz=File,
diff --git a/src/engine/SCons/Script/SConscript.py b/src/engine/SCons/Script/SConscript.py
index 4c47078..1c17ee2 100644
--- a/src/engine/SCons/Script/SConscript.py
+++ b/src/engine/SCons/Script/SConscript.py
@@ -30,21 +30,21 @@ files.
 
 __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__"
 
-import SCons
 import SCons.Action
 import SCons.Builder
 import SCons.Defaults
 import SCons.Environment
 import SCons.Errors
 import SCons.Node
-import SCons.Node.Alias
 import SCons.Node.FS
-import SCons.Options
+import SCons.Node.Python
 import SCons.Platform
 import SCons.SConf
 import SCons.Script
-import SCons.Tool
 import SCons.Util
+import SCons.Options
+import SCons
+import SCons.Node.Alias
 
 import os
 import os.path
@@ -52,13 +52,13 @@ import re
 import string
 import sys
 import traceback
-import types
 
 def do_nothing(text): pass
 HelpFunction = do_nothing
 
+default_targets = None
+clean_targets = {}
 arguments = {}
-GlobalDict = {}
 launch_dir = os.path.abspath(os.curdir)
 
 # global exports set by Export():
@@ -67,8 +67,9 @@ global_exports = {}
 # chdir flag
 sconscript_chdir = 1
 
-# will be set to 1, if we are reading a SConscript
-sconscript_reading = 0
+def SConscriptChdir(flag):
+    global sconscript_chdir
+    sconscript_chdir = flag
 
 def _scons_add_args(alist):
     global arguments
@@ -80,7 +81,7 @@ def get_calling_namespaces():
     """Return the locals and globals for the function that called
     into this module in the current callstack."""
     try: 1/0
-    except ZeroDivisionError: frame = sys.exc_info()[2].tb_frame
+    except: frame = sys.exc_info()[2].tb_frame
     
     while frame.f_globals.get("__name__") == __name__: frame = frame.f_back
 
@@ -91,6 +92,7 @@ def compute_exports(exports):
     """Compute a dictionary of exports given one of the parameters
     to the Export() function or the exports argument to SConscript()."""
 
+    exports = SCons.Util.Split(exports)
     loc, glob = get_calling_namespaces()
 
     retval = {}
@@ -141,12 +143,82 @@ def Return(*vars):
     else:
         stack[-1].retval = tuple(retval)
 
-def _SConscript(fs, *files, **kw):
-    global sconscript_reading
-    sconscript_reading = 1
-    top = fs.Top
-    sd = fs.SConstruct_dir.rdir()
-    exports = kw.get('exports', [])
+# This function is responsible for converting the parameters passed to
+# SConscript() calls into a list of files and export variables.  If the
+# parameters are invalid, throws SCons.Errors.UserError. Returns a tuple
+# (l, e) where l is a list of SConscript filenames and e is a list of
+# exports.
+
+def GetSConscriptFilenames(ls, kw):
+    exports = []
+
+    if len(ls) == 0:
+        try:
+            dirs = kw["dirs"]
+        except KeyError:
+            raise SCons.Errors.UserError, \
+                  "Invalid SConscript usage - no parameters"
+
+        if not SCons.Util.is_List(dirs):
+            dirs = [ dirs ]
+        dirs = map(str, dirs)
+
+        name = kw.get('name', 'SConscript')
+
+        files = map(lambda n, name = name: os.path.join(n, name), dirs)
+
+    elif len(ls) == 1:
+
+        files = ls[0]
+
+    elif len(ls) == 2:
+
+        files   = ls[0]
+        exports = SCons.Util.Split(ls[1])
+
+    else:
+
+        raise SCons.Errors.UserError, \
+              "Invalid SConscript() usage - too many arguments"
+
+    if not SCons.Util.is_List(files):
+        files = [ files ]
+
+    if kw.get('exports'):
+        exports.extend(SCons.Util.Split(kw['exports']))
+
+    build_dir = kw.get('build_dir')
+    if build_dir:
+        if len(files) != 1:
+            raise SCons.Errors.UserError, \
+                "Invalid SConscript() usage - can only specify one SConscript with a build_dir"
+        duplicate = kw.get('duplicate', 1)
+        src_dir = kw.get('src_dir')
+        if not src_dir:
+            src_dir, fname = os.path.split(str(files[0]))
+        else:
+            if not isinstance(src_dir, SCons.Node.Node):
+                src_dir = SCons.Node.FS.default_fs.Dir(src_dir)
+            fn = files[0]
+            if not isinstance(fn, SCons.Node.Node):
+                fn = SCons.Node.FS.default_fs.File(fn)
+            if fn.is_under(src_dir):
+                # Get path relative to the source directory.
+                fname = fn.get_path(src_dir)
+            else:
+                # Fast way to only get the terminal path component of a Node.
+                fname = fn.get_path(fn.dir)
+        BuildDir(build_dir, src_dir, duplicate)
+        files = [os.path.join(str(build_dir), fname)]
+
+    return (files, exports)
+
+def SConscript(*ls, **kw):
+    files, exports = GetSConscriptFilenames(ls, kw)
+
+    default_fs = SCons.Node.FS.default_fs
+    top = default_fs.Top
+    sd = default_fs.SConstruct_dir.rdir()
 
     # evaluate each SConscript file
     results = []
@@ -160,13 +232,14 @@ def _SConscript(fs, *files, **kw):
                 if isinstance(fn, SCons.Node.Node):
                     f = fn
                 else:
-                    f = fs.File(str(fn))
+                    f = default_fs.File(str(fn))
                 _file_ = None
 
                 # Change directory to the top of the source
                 # tree to make sure the os's cwd and the cwd of
-                # fs match so we can open the SConscript.
-                fs.chdir(top, change_os_dir=1)
+                # SCons.Node.FS.default_fs match so we can open the
+                # SConscript.
+                default_fs.chdir(top, change_os_dir=1)
                 if f.rexists():
                     _file_ = open(f.rstr(), "r")
                 elif f.has_src_builder():
@@ -190,17 +263,17 @@ def _SConscript(fs, *files, **kw):
                     # where the SConstruct and SConscript files might be
                     # in different Repositories.  For now, cross that
                     # bridge when someone comes to it.
-                    ldir = fs.Dir(f.dir.get_path(sd))
+                    ldir = default_fs.Dir(f.dir.get_path(sd))
                     try:
-                        fs.chdir(ldir, change_os_dir=sconscript_chdir)
+                        default_fs.chdir(ldir, change_os_dir=sconscript_chdir)
                     except OSError:
                         # There was no local directory, so we should be
                         # able to chdir to the Repository directory.
                         # Note that we do this directly, not through
-                        # fs.chdir(), because we still need to
+                        # default_fs.chdir(), because we still need to
                         # interpret the stuff within the SConscript file
                         # relative to where we are logically.
-                        fs.chdir(ldir, change_os_dir=0)
+                        default_fs.chdir(ldir, change_os_dir=0)
                         os.chdir(f.rfile().dir.get_abspath())
 
                     # Append the SConscript directory to the beginning
@@ -220,16 +293,15 @@ def _SConscript(fs, *files, **kw):
                                      f.path)
                 
         finally:
-            sconscript_reading = 0
             sys.path = old_sys_path
             frame = stack.pop()
             try:
-                fs.chdir(frame.prev_dir, change_os_dir=sconscript_chdir)
+                default_fs.chdir(frame.prev_dir, change_os_dir=sconscript_chdir)
             except OSError:
                 # There was no local directory, so chdir to the
                 # Repository directory.  Like above, we do this
                 # directly.
-                fs.chdir(frame.prev_dir, change_os_dir=0)
+                default_fs.chdir(frame.prev_dir, change_os_dir=0)
                 os.chdir(frame.prev_dir.rdir().get_abspath())
 
             results.append(frame.retval)
@@ -284,196 +356,129 @@ def annotate(node):
 # leave this disabled until we find a more efficient mechanism.
 #SCons.Node.Annotate = annotate
 
-class SConsEnvironment(SCons.Environment.Base):
-    """An Environment subclass that contains all of the methods that
-    are particular to the wrapper SCons interface and which aren't
-    (or shouldn't be) part of the build engine itself.
-
-    Note that not all of the methods of this class have corresponding
-    global functions, there are some private methods.
-    """
-
-    #
-    # Private methods of an SConsEnvironment.
-    #
-
-    def _check_version(self, major, minor, version_string):
-        """Return 0 if 'major' and 'minor' are greater than the version
-        in 'version_string', and 1 otherwise."""
-        try:
-            v_major, v_minor, v_micro, release, serial = sys.version_info
-        except AttributeError:
-            version = string.split(string.split(version_string, ' ')[0], '.')
-            v_major = int(version[0])
-            v_minor = int(re.match('\d+', version[1]).group())
-        if major > v_major or (major == v_major and minor > v_minor):
-            return 0
+def Default(*targets):
+    global default_targets
+    if default_targets is None:
+        default_targets = []
+    for t in targets:
+        if t is None:
+            default_targets = []
+        elif isinstance(t, SCons.Node.Node):
+            default_targets.append(t)
         else:
-            return 1
-
-    def _get_SConscript_filenames(self, ls, kw):
-        """
-        Convert the parameters passed to # SConscript() calls into a list
-        of files and export variables.  If the parameters are invalid,
-        throws SCons.Errors.UserError. Returns a tuple (l, e) where l
-        is a list of SConscript filenames and e is a list of exports.
-        """
-        exports = []
-
-        if len(ls) == 0:
-            try:
-                dirs = kw["dirs"]
-            except KeyError:
-                raise SCons.Errors.UserError, \
-                      "Invalid SConscript usage - no parameters"
-
-            if not SCons.Util.is_List(dirs):
-                dirs = [ dirs ]
-            dirs = map(str, dirs)
-
-            name = kw.get('name', 'SConscript')
+            default_targets.extend(SCons.Node.arg2nodes(t,
+                                         SCons.Node.FS.default_fs.Entry))
 
-            files = map(lambda n, name = name: os.path.join(n, name), dirs)
+def Local(*targets):
+    for targ in targets:
+        if isinstance(targ, SCons.Node.Node):
+            targ.set_local()
+        else:
+            for t in SCons.Node.arg2nodes(targ, SCons.Node.FS.default_fs.Entry):
+               t.set_local()
 
-        elif len(ls) == 1:
+def Help(text):
+    HelpFunction(text)
 
-            files = ls[0]
+def BuildDir(build_dir, src_dir, duplicate=1):
+    SCons.Node.FS.default_fs.BuildDir(build_dir, src_dir, duplicate)
 
-        elif len(ls) == 2:
+def GetBuildPath(files):
+    nodes = SCons.Node.arg2nodes(files, SCons.Node.FS.default_fs.Entry)
+    ret = map(str, nodes)
+    if len(ret) == 1:
+        return ret[0]
+    return ret
 
-            files   = ls[0]
-            exports = self.Split(ls[1])
+def FindFile(file, dirs):
+    nodes = SCons.Node.arg2nodes(dirs, SCons.Node.FS.default_fs.Dir)
+    return SCons.Node.FS.find_file(file, nodes)
 
-        else:
+def Export(*vars):
+    for var in vars:
+        global_exports.update(compute_exports(var))
 
-            raise SCons.Errors.UserError, \
-                  "Invalid SConscript() usage - too many arguments"
-
-        if not SCons.Util.is_List(files):
-            files = [ files ]
-
-        if kw.get('exports'):
-            exports.extend(self.Split(kw['exports']))
-
-        build_dir = kw.get('build_dir')
-        if build_dir:
-            if len(files) != 1:
-                raise SCons.Errors.UserError, \
-                    "Invalid SConscript() usage - can only specify one SConscript with a build_dir"
-            duplicate = kw.get('duplicate', 1)
-            src_dir = kw.get('src_dir')
-            if not src_dir:
-                src_dir, fname = os.path.split(str(files[0]))
-            else:
-                if not isinstance(src_dir, SCons.Node.Node):
-                    src_dir = self.fs.Dir(src_dir)
-                fn = files[0]
-                if not isinstance(fn, SCons.Node.Node):
-                    fn = self.fs.File(fn)
-                if fn.is_under(src_dir):
-                    # Get path relative to the source directory.
-                    fname = fn.get_path(src_dir)
-                else:
-                    # Fast way to only get the terminal path component of a Node.
-                    fname = fn.get_path(fn.dir)
-            self.fs.BuildDir(build_dir, src_dir, duplicate)
-            files = [os.path.join(str(build_dir), fname)]
-
-        return (files, exports)
-
-    #
-    # Public methods of an SConsEnvironment.  These get
-    # entry points in the global name space so they can be called
-    # as global functions.
-    #
-
-    def EnsureSConsVersion(self, major, minor):
-        """Exit abnormally if the SCons version is not late enough."""
-        if not self._check_version(major,minor,SCons.__version__):
-            print "SCons %d.%d or greater required, but you have SCons %s" %(major,minor,SCons.__version__)
-            sys.exit(2)
-
-    def EnsurePythonVersion(self, major, minor):
-        """Exit abnormally if the Python version is not late enough."""
-        if not self._check_version(major,minor,sys.version):
-            v = string.split(sys.version, " ", 1)[0]
-            print "Python %d.%d or greater required, but you have Python %s" %(major,minor,v)
-            sys.exit(2)
-
-    def Exit(self, value=0):
-        sys.exit(value)
-
-    def Export(self, *vars):
+def Import(*vars):
+    try:
         for var in vars:
-            global_exports.update(compute_exports(self.Split(var)))
-
-    def GetLaunchDir(self):
-        global launch_dir
-        return launch_dir
-
-    def GetOption(self, name):
-        name = self.subst(name)
-        return SCons.Script.ssoptions.get(name)
-
-    def Help(self, text):
-        text = self.subst(text, raw=1)
-        HelpFunction(text)
-
-    def Import(self, *vars):
-        try:
-            for var in vars:
-                var = self.Split(var)
-                for v in var:
-                    if v == '*':
-                        stack[-1].globals.update(global_exports)
-                        stack[-1].globals.update(stack[-1].exports)
+            var = SCons.Util.Split(var)
+            for v in var:
+                if v == '*':
+                    stack[-1].globals.update(global_exports)
+                    stack[-1].globals.update(stack[-1].exports)
+                else:
+                    if stack[-1].exports.has_key(v):
+                        stack[-1].globals[v] = stack[-1].exports[v]
                     else:
-                        if stack[-1].exports.has_key(v):
-                            stack[-1].globals[v] = stack[-1].exports[v]
-                        else:
-                            stack[-1].globals[v] = global_exports[v]
-        except KeyError,x:
-            raise SCons.Errors.UserError, "Import of non-existant variable '%s'"%x
+                        stack[-1].globals[v] = global_exports[v]
+    except KeyError,x:
+        raise SCons.Errors.UserError, "Import of non-existant variable '%s'"%x
 
-    def SConscript(self, *ls, **kw):
-        ls = map(lambda l, self=self: self.subst(l), ls)
-        subst_kw = {}
-        for key, val in kw.items():
-            if SCons.Util.is_String(val):
-                val = self.subst(val)
-            subst_kw[key] = val
-
-        files, exports = self._get_SConscript_filenames(ls, subst_kw)
-
-        return apply(_SConscript, [self.fs,] + files, {'exports' : exports})
-
-    def SConscriptChdir(self, flag):
-        global sconscript_chdir
-        sconscript_chdir = flag
-
-    def SetOption(self, name, value):
-        name = self.subst(name)
-        SCons.Script.ssoptions.set(name, value)
-
-#
-#
-#
-SCons.Environment.Environment = SConsEnvironment
-
-def Options(files=None, args=arguments):
-    return SCons.Options.Options(files, args)
+def GetLaunchDir():
+    return launch_dir
 
 def SetBuildSignatureType(type):
     SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
                         "The SetBuildSignatureType() function has been deprecated;\n" +\
                         "\tuse the TargetSignatures() function instead.")
-    SCons.Defaults.DefaultEnvironment().TargetSignatures(type)
+    TargetSignatures(type)
+
+def TargetSignatures(type):
+    import SCons.Sig
+    if type == 'build':
+        SCons.Sig.build_signature = 1
+    elif type == 'content':
+        SCons.Sig.build_signature = 0
+    else:
+        raise SCons.Errors.UserError, "Unknown build signature type '%s'"%type
 
 def SetContentSignatureType(type):
     SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
                         "The SetContentSignatureType() function has been deprecated;\n" +\
                         "\tuse the SourceSignatures() function instead.")
-    SCons.Defaults.DefaultEnvironment().SourceSignatures(type)
+    SourceSignatures(type)
+
+def SourceSignatures(type):
+    if type == 'MD5':
+        import SCons.Sig.MD5
+        SCons.Script.sig_module = SCons.Sig.MD5
+    elif type == 'timestamp':
+        import SCons.Sig.TimeStamp
+        SCons.Script.sig_module = SCons.Sig.TimeStamp
+    else:
+        raise SCons.Errors.UserError, "Unknown content signature type '%s'"%type
+
+
+class Options(SCons.Options.Options):
+    def __init__(self, files=None, args=arguments):
+        SCons.Options.Options.__init__(self, files, args)
+
+def CheckVersion(major, minor, version_string):
+    """Return 0 if 'major' and 'minor' are greater than the version
+    in 'version_string', and 1 otherwise."""
+    try:
+        v_major, v_minor, v_micro, release, serial = sys.version_info
+    except AttributeError:
+        version = string.split(string.split(version_string, ' ')[0], '.')
+        v_major = int(version[0])
+        v_minor = int(re.match('\d+', version[1]).group())
+    if major > v_major or (major == v_major and minor > v_minor):
+        return 0
+    else:
+        return 1
+
+def EnsureSConsVersion(major, minor):
+    """Exit abnormally if the SCons version is not late enough."""
+    if not CheckVersion(major,minor,SCons.__version__):
+        print "SCons %d.%d or greater required, but you have SCons %s" %(major,minor,SCons.__version__)
+        sys.exit(2)
+
+def EnsurePythonVersion(major, minor):
+    """Exit abnormally if the Python version is not late enough."""
+    if not CheckVersion(major,minor,sys.version):
+	v = string.split(sys.version, " ", 1)[0]
+        print "Python %d.%d or greater required, but you have Python %s" %(major,minor,v)
+        sys.exit(2)
 
 def GetJobs():
     SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
@@ -487,140 +492,58 @@ def SetJobs(num):
                         "The SetJobs() function has been deprecated;\n" +\
                         "\tuse SetOption('num_jobs', num) instead.")
     SetOption('num_jobs', num)
- 
-def ParseConfig(env, command, function=None):
-    SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
-                        "The ParseConfig() function has been deprecated;\n" +\
-                        "\tuse the env.ParseConfig() method instead.")
-    return env.ParseConfig(command, function)
 
-#
-_DefaultEnvironmentProxy = None
-
-def get_DefaultEnvironmentProxy():
-    global _DefaultEnvironmentProxy
-    if not _DefaultEnvironmentProxy:
-        class EnvironmentProxy(SCons.Environment.Environment):
-            """A proxy subclass for an environment instance that overrides
-            the subst() and subst_list() methods so they don't actually
-            actually perform construction variable substitution.  This is
-            specifically intended to be the shim layer in between global
-            function calls (which don't want want construction variable
-            substitution) and the DefaultEnvironment() (which would
-            substitute variables if left to its own devices)."""
-            def __init__(self, subject):
-                self.__dict__['__subject'] = subject
-            def __getattr__(self, name):
-                return getattr(self.__dict__['__subject'], name)
-            def __setattr__(self, name, value):
-                return setattr(self.__dict__['__subject'], name, value)
-            def subst(self, string, raw=0, target=None, source=None):
-                return string
-            def subst_kw(self, kw, raw=0, target=None, source=None):
-                return kw
-            def subst_list(self, string, raw=0, target=None, source=None):
-                return string
-        default_env = SCons.Defaults.DefaultEnvironment()
-        _DefaultEnvironmentProxy = EnvironmentProxy(default_env)
-    return _DefaultEnvironmentProxy
-
-class DefaultEnvironmentCall:
-    """A class that implements "global function" calls of
-    Environment methods by fetching the specified method from the
-    DefaultEnvironment's class.  Note that this uses an intermediate
-    proxy class instead of calling the DefaultEnvironment method
-    directly so that the proxy can override the subst() method and
-    thereby prevent expansion of construction variables (since from
-    the user's point of view this was called as a global function,
-    with no associated construction environment)."""
-    def __init__(self, method_name):
-        self.method_name = method_name
-    def __call__(self, *args, **kw):
-        proxy = get_DefaultEnvironmentProxy()
-        method = getattr(proxy, self.method_name)
-        return apply(method, args, kw)
-
-# The list of global functions to add to the SConscript name space
-# that end up calling corresponding methods or Builders in the
-# DefaultEnvironment().
-GlobalDefaultEnvironmentFunctions = [
-    # Methods from the SConsEnvironment class, above.
-    'EnsurePythonVersion',
-    'EnsureSConsVersion',
-    'Exit',
-    'Export',
-    'GetLaunchDir',
-    'GetOption',
-    'Help',
-    'Import',
-    'SConscript',
-    'SConscriptChdir',
-    'SetOption',
-
-    # Methods from the Environment.Base class.
-    'Action',
-    'AddPostAction',
-    'AddPreAction',
-    'Alias',
-    'AlwaysBuild',
-    'BuildDir',
-    'Builder',
-    'CacheDir',
-    'Clean',
-    'Command',
-    'Default',
-    'Depends',
-    'Dir',
-    'Environment',
-    'File',
-    'FindFile',
-    'GetBuildPath',
-    'Ignore',
-    'Install',
-    'InstallAs',
-    'Literal',
-    'Local',
-    'Precious',
-    'Repository',
-    'Scanner',
-    'SConsignFile',
-    'SideEffect',
-    'SourceCode',
-    'SourceSignatures',
-    'Split',
-    'TargetSignatures',
-    'Value',
-]
-
-GlobalDefaultBuilders = [
-    # Supported builders.
-    'CFile',
-    'CXXFile',
-    'DVI',
-    'Jar',
-    'Java',
-    'JavaH',
-    'Library',
-    'M4',
-    'MSVSProject',
-    'Object',
-    'PCH',
-    'PDF',
-    'PostScript',
-    'Program',
-    'RES',
-    'RMIC',
-    'SharedLibrary',
-    'SharedObject',
-    'StaticLibrary',
-    'StaticObject',
-    'Tar',
-    'TypeLibrary',
-    'Zip',
-]
-
-for name in GlobalDefaultEnvironmentFunctions + GlobalDefaultBuilders:
-    GlobalDict[name] = DefaultEnvironmentCall(name)
+def Clean(target, files):
+    if not isinstance(target, SCons.Node.Node):
+        target = SCons.Node.FS.default_fs.Entry(target, create=1)
+
+    if not SCons.Util.is_List(files):
+        files = [files]
+
+    nodes = []
+    for f in files:
+        if isinstance(f, SCons.Node.Node):
+            nodes.append(f)
+        else:
+            nodes.extend(SCons.Node.arg2nodes(f, SCons.Node.FS.default_fs.Entry))
+
+    try:
+        clean_targets[target].extend(nodes)
+    except KeyError:
+        clean_targets[target] = nodes
+
+def AddPreAction(files, action):
+    nodes = SCons.Node.arg2nodes(files, SCons.Node.FS.default_fs.Entry)
+    for n in nodes:
+        n.add_pre_action(SCons.Action.Action(action))
+
+def AddPostAction(files, action):
+    nodes = SCons.Node.arg2nodes(files, SCons.Node.FS.default_fs.Entry)
+    for n in nodes:
+        n.add_post_action(SCons.Action.Action(action))
+
+def Exit(value=0):
+    sys.exit(value)
+
+
+def Alias(name):
+    alias = SCons.Node.Alias.default_ans.lookup(name)
+    if alias is None:
+        alias = SCons.Node.Alias.default_ans.Alias(name)
+    return alias
+
+def SetOption(name, value):
+    SCons.Script.ssoptions.set(name, value)
+
+def GetOption(name):
+    return SCons.Script.ssoptions.get(name)
+
+def SConsignFile(name=".sconsign.dbm"):
+    import SCons.Sig
+    if not os.path.isabs(name):
+        sd = str(SCons.Node.FS.default_fs.SConstruct_dir)
+        name = os.path.join(sd, name)
+    SCons.Sig.SConsignFile(name)
 
 def BuildDefaultGlobals():
     """
@@ -629,25 +552,54 @@ def BuildDefaultGlobals():
     """
 
     globals = {}
+    globals['Action']            = SCons.Action.Action
+    globals['AddPostAction']     = AddPostAction
+    globals['AddPreAction']      = AddPreAction
+    globals['Alias']             = Alias
     globals['ARGUMENTS']         = arguments
+    globals['BuildDir']          = BuildDir
+    globals['Builder']           = SCons.Builder.Builder
+    globals['CacheDir']          = SCons.Node.FS.default_fs.CacheDir
+    globals['Clean']             = Clean
     globals['Configure']         = SCons.SConf.SConf
-    globals['Options']           = Options
-    globals['Platform']          = SCons.Platform.Platform
-    globals['Return']            = Return
-    globals['Tool']              = SCons.Tool.Tool
-    globals['WhereIs']           = SCons.Util.WhereIs
-
-    # Functions we're in the process of converting to Environment methods.
     globals['CScan']             = SCons.Defaults.CScan
+    globals['Default']           = Default
     globals['DefaultEnvironment'] = SCons.Defaults.DefaultEnvironment
-
-    # Deprecated functions, leave these here for now.
+    globals['Dir']               = SCons.Node.FS.default_fs.Dir
+    globals['EnsurePythonVersion'] = EnsurePythonVersion
+    globals['EnsureSConsVersion'] = EnsureSConsVersion
+    globals['Environment']       = SCons.Environment.Environment
+    globals['Exit']              = Exit
+    globals['Export']            = Export
+    globals['File']              = SCons.Node.FS.default_fs.File
+    globals['FindFile']          = FindFile
+    globals['GetBuildPath']      = GetBuildPath
+    globals['GetCommandHandler'] = SCons.Action.GetCommandHandler
     globals['GetJobs']           = GetJobs
-    globals['ParseConfig']       = ParseConfig
+    globals['GetLaunchDir']      = GetLaunchDir
+    globals['GetOption']         = GetOption    
+    globals['Help']              = Help
+    globals['Import']            = Import
+    globals['Literal']           = SCons.Util.Literal
+    globals['Local']             = Local
+    globals['Options']           = Options
+    globals['ParseConfig']       = SCons.Util.ParseConfig
+    globals['Platform']          = SCons.Platform.Platform
+    globals['Repository']        = SCons.Node.FS.default_fs.Repository
+    globals['Return']            = Return
+    globals['SConscript']        = SConscript
+    globals['SConscriptChdir']   = SConscriptChdir
+    globals['SConsignFile']      = SConsignFile
+    globals['Scanner']           = SCons.Scanner.Base
     globals['SetBuildSignatureType'] = SetBuildSignatureType
+    globals['SetCommandHandler'] = SCons.Action.SetCommandHandler
     globals['SetContentSignatureType'] = SetContentSignatureType
     globals['SetJobs']           = SetJobs
-
-    globals.update(GlobalDict)
-
+    globals['SetOption']         = SetOption
+    globals['SourceSignatures']  = SourceSignatures
+    globals['Split']             = SCons.Util.Split
+    globals['TargetSignatures']  = TargetSignatures
+    globals['Tool']              = SCons.Tool.Tool
+    globals['Value']             = SCons.Node.Python.Value
+    globals['WhereIs']           = SCons.Util.WhereIs
     return globals
diff --git a/src/engine/SCons/Sig/SigTests.py b/src/engine/SCons/Sig/SigTests.py
index f297464..c82d2c5 100644
--- a/src/engine/SCons/Sig/SigTests.py
+++ b/src/engine/SCons/Sig/SigTests.py
@@ -490,41 +490,6 @@ class SConsignDirFileTestCase(unittest.TestCase):
         assert f.get('foo') == (3, 1, 2)
         assert f.get_implicit('foo') == ['bar']
 
-class SConsignFileTestCase(unittest.TestCase):
-
-    def runTest(self):
-        test = TestCmd.TestCmd(workdir = '')
-        file = test.workpath('sconsign_file')
-
-        assert SCons.Sig.SConsign_db is None, SCons.Sig.SConsign_db
-
-        SCons.Sig.SConsignFile(file)
-
-        assert not SCons.Sig.SConsign_db is None, SCons.Sig.SConsign_db
-
-        class Fake_DBM:
-            def open(self, name, mode):
-                self.name = name
-                self.mode = mode
-                return self
-
-        fake_dbm = Fake_DBM()
-
-        SCons.Sig.SConsignFile(file, fake_dbm)
-
-        assert not SCons.Sig.SConsign_db is None, SCons.Sig.SConsign_db
-        assert not hasattr(fake_dbm, 'name'), fake_dbm
-        assert not hasattr(fake_dbm, 'mode'), fake_dbm
-
-        SCons.Sig.SConsign_db = None
-
-        SCons.Sig.SConsignFile(file, fake_dbm)
-
-        assert not SCons.Sig.SConsign_db is None, SCons.Sig.SConsign_db
-        assert fake_dbm.name == file, fake_dbm.name
-        assert fake_dbm.mode == "c", fake_dbm.mode
-
-
 
 def suite():
     suite = unittest.TestSuite()
@@ -535,7 +500,6 @@ def suite():
     suite.addTest(_SConsignTestCase())
     suite.addTest(SConsignDBTestCase())
     suite.addTest(SConsignDirFileTestCase())
-    suite.addTest(SConsignFileTestCase())
     return suite
 
 if __name__ == "__main__":
diff --git a/src/engine/SCons/Sig/__init__.py b/src/engine/SCons/Sig/__init__.py
index a2ebd5c..298db66 100644
--- a/src/engine/SCons/Sig/__init__.py
+++ b/src/engine/SCons/Sig/__init__.py
@@ -51,6 +51,10 @@ sig_files = []
 
 SConsign_db = None
 
+# 1 means use build signature for derived source files
+# 0 means use content signature for derived source files
+build_signature = 1
+
 def write():
     global sig_files
     for sig_file in sig_files:
@@ -117,7 +121,7 @@ class _SConsign:
         """
         try:
             return self.entries[filename]
-        except (KeyError, AttributeError):
+        except:
             return SConsignEntry()
 
     def set_entry(self, filename, entry):
@@ -198,8 +202,6 @@ class SConsignDB(_SConsign):
                 if type(self.entries) is not type({}):
                     self.entries = {}
                     raise TypeError
-            except KeyboardInterrupt:
-                raise
             except:
                 SCons.Warnings.warn(SCons.Warnings.CorruptSConsignWarning,
                                     "Ignoring corrupt sconsign entry : %s"%self.dir.path)
@@ -211,11 +213,7 @@ class SConsignDB(_SConsign):
         if self.dirty:
             global SConsign_db
             SConsign_db[self.dir.path] = cPickle.dumps(self.entries, 1)
-            try:
-                SConsign_db.sync()
-            except AttributeError:
-                # Not all anydbm modules have sync() methods.
-                pass
+            SConsign_db.sync()
 
 class SConsignDir(_SConsign):
     def __init__(self, fp=None, module=None):
@@ -246,13 +244,11 @@ class SConsignDirFile(SConsignDir):
 
         try:
             fp = open(self.sconsign, 'rb')
-        except IOError:
+        except:
             fp = None
 
         try:
             SConsignDir.__init__(self, fp, module)
-        except KeyboardInterrupt:
-            raise
         except:
             SCons.Warnings.warn(SCons.Warnings.CorruptSConsignWarning,
                                 "Ignoring corrupt .sconsign file: %s"%self.sconsign)
@@ -278,11 +274,11 @@ class SConsignDirFile(SConsignDir):
             try:
                 file = open(temp, 'wb')
                 fname = temp
-            except IOError:
+            except:
                 try:
                     file = open(self.sconsign, 'wb')
                     fname = self.sconsign
-                except IOError:
+                except:
                     return
             cPickle.dump(self.entries, file, 1)
             file.close()
@@ -291,31 +287,29 @@ class SConsignDirFile(SConsignDir):
                     mode = os.stat(self.sconsign)[0]
                     os.chmod(self.sconsign, 0666)
                     os.unlink(self.sconsign)
-                except OSError:
+                except:
                     pass
                 try:
                     os.rename(fname, self.sconsign)
-                except OSError:
+                except:
                     open(self.sconsign, 'wb').write(open(fname, 'rb').read())
                     os.chmod(self.sconsign, mode)
             try:
                 os.unlink(temp)
-            except OSError:
+            except:
                 pass
 
 SConsignForDirectory = SConsignDirFile
 
-def SConsignFile(name, dbm_module=None):
+def SConsignFile(name):
     """
     Arrange for all signatures to be stored in a global .sconsign.dbm
     file.
     """
     global SConsign_db
     if SConsign_db is None:
-        if dbm_module is None:
-            import anydbm
-            dbm_module = anydbm
-        SConsign_db = dbm_module.open(name, "c")
+        import anydbm
+        SConsign_db = anydbm.open(name, "c")
 
     global SConsignForDirectory
     SConsignForDirectory = SConsignDB
diff --git a/src/engine/SCons/Tool/c++.py b/src/engine/SCons/Tool/c++.py
index 1a6c6c0..9e8a9f9 100644
--- a/src/engine/SCons/Tool/c++.py
+++ b/src/engine/SCons/Tool/c++.py
@@ -68,10 +68,10 @@ def generate(env):
         
     env['CXX']        = 'c++'
     env['CXXFLAGS']   = '$CCFLAGS'
-    env['CXXCOM']     = '$CXX $CXXFLAGS $CPPFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'
+    env['CXXCOM']     = '$CXX $CXXFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'
     env['SHCXX']      = '$CXX'
     env['SHCXXFLAGS'] = '$CXXFLAGS'
-    env['SHCXXCOM']   = '$SHCXX $SHCXXFLAGS $CPPFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'
+    env['SHCXXCOM']   = '$SHCXX $SHCXXFLAGS $CPPFLAGS $_CPPDEFFLAGS $_CPPINCFLAGS -c -o $TARGET $SOURCES'
 
     env['CPPDEFPREFIX']  = '-D'
     env['CPPDEFSUFFIX']  = ''
diff --git a/src/script/sconsign.py b/src/script/sconsign.py
index cc9e58d..015f1db 100644
--- a/src/script/sconsign.py
+++ b/src/script/sconsign.py
@@ -80,7 +80,6 @@ if sys.platform == 'win32':
     # sys.prefix is (likely) C:\Python*;
     # check only C:\Python*.
     prefs.append(sys.prefix)
-    prefs.append(os.path.join(sys.prefix, 'Lib', 'site-packages'))
 else:
     # On other (POSIX) platforms, things are more complicated due to
     # the variety of path names and library locations.  Try to be smart
@@ -122,13 +121,7 @@ else:
         # check only /foo/lib/scons*.
         prefs.append(sys.prefix)
 
-    temp = map(lambda x: os.path.join(x, 'lib'), prefs)
-    temp.extend(map(lambda x: os.path.join(x,
-                                           'lib',
-                                           'python' + sys.version[:3],
-                                           'site-packages'),
-                           prefs))
-    prefs = temp
+    prefs = map(lambda x: os.path.join(x, 'lib'), prefs)
 
 # Look first for 'scons-__version__' in all of our preference libs,
 # then for 'scons'.