Add BUILD_TARGETS, COMMAND_LINE_TARGETS and DEFAULT_TARGETS variables.

5 files changed, 84 insertions, 64 deletions

diff --git a/src/CHANGES.txt b/src/CHANGES.txt
index 2905339..8629589 100644
--- a/src/CHANGES.txt
+++ b/src/CHANGES.txt
@@ -25,6 +25,8 @@ RELEASE X.XX - XXX, XX XXX XXXX XX:XX:XX -XXXX
 
   - Fix subclassing the Environment and Scanner classes.
 
+  - Add BUILD_TARGETS, COMMAND_LINE_TARGETS and DEFAULT_TARGETS variables.
+
   From Steve Leblanc:
 
   - SGI fixes:  Fix C++ compilation, add a separate Tool/sgic++.py module.
diff --git a/src/engine/SCons/Environment.py b/src/engine/SCons/Environment.py
index 6c6ad8a..26be483 100644
--- a/src/engine/SCons/Environment.py
+++ b/src/engine/SCons/Environment.py
@@ -64,7 +64,6 @@ class _Null:
 
 _null = _Null
 
-DefaultTargets = None
 CleanTargets = {}
 CalculatorArgs = {}
 
@@ -811,18 +810,6 @@ class Base:
                                     source_factory=self.fs.Entry)
         return bld(self, target, source)
 
-    def Default(self, *targets):
-        global DefaultTargets
-        if DefaultTargets is None:
-            DefaultTargets = []
-        for t in targets:
-            if t is None:
-                DefaultTargets = []
-            elif isinstance(t, SCons.Node.Node):
-                DefaultTargets.append(t)
-            else:
-                DefaultTargets.extend(self.arg2nodes(t, self.fs.Entry))
-
     def Depends(self, target, dependency):
         """Explicity specify that 'target's depend on 'dependency'."""
         tlist = self.arg2nodes(target, self.fs.Entry)
diff --git a/src/engine/SCons/EnvironmentTests.py b/src/engine/SCons/EnvironmentTests.py
index 2861f85..e6fd5c9 100644
--- a/src/engine/SCons/EnvironmentTests.py
+++ b/src/engine/SCons/EnvironmentTests.py
@@ -1484,25 +1484,6 @@ class EnvironmentTestCase(unittest.TestCase):
         finally:
             os.chdir(save)
 
-    def test_Default(self):
-        """Test the Default() method"""
-        env = Environment(FOO = 'fff', BAR = 'bbb')
-
-        t = env.Default(None)
-        assert SCons.Environment.DefaultTargets == []
-
-        t = env.Default('xyz')
-        d = map(str, SCons.Environment.DefaultTargets)
-        assert d == ['xyz'], d
-
-        t = env.Default('$FOO')
-        d = map(str, SCons.Environment.DefaultTargets)
-        assert d == ['xyz', 'fff'], d
-
-        t = env.Default(None, '$BAR', 'another_file')
-        d = map(str, SCons.Environment.DefaultTargets)
-        assert d == ['bbb', 'another_file'], d
-
     def test_Depends(self):
         """Test the explicit Depends method."""
         env = Environment(FOO = 'xxx', BAR='yyy')
diff --git a/src/engine/SCons/Script/SConscript.py b/src/engine/SCons/Script/SConscript.py
index fff1869..8894df7 100644
--- a/src/engine/SCons/Script/SConscript.py
+++ b/src/engine/SCons/Script/SConscript.py
@@ -53,13 +53,27 @@ import string
 import sys
 import traceback
 import types
+import UserList
+
+launch_dir = os.path.abspath(os.curdir)
 
 def do_nothing(text): pass
 HelpFunction = do_nothing
 
-arguments = {}
+Arguments = {}
+CommandLineTargets = []
+DefaultCalled = None
+DefaultTargets = []
 GlobalDict = {}
-launch_dir = os.path.abspath(os.curdir)
+
+class TargetList(UserList.UserList):
+    def _do_nothing(self, *args, **kw):
+        pass
+    def _add_Default(self, list):
+        self.extend(list)
+    def _clear(self):
+        del self[:]
+BuildTargets = TargetList()
 
 # global exports set by Export():
 global_exports = {}
@@ -71,10 +85,16 @@ sconscript_chdir = 1
 sconscript_reading = 0
 
 def _scons_add_args(alist):
-    global arguments
     for arg in alist:
         a, b = string.split(arg, '=', 2)
-        arguments[a] = b
+        Arguments[a] = b
+
+def _scons_add_targets(tlist):
+    if tlist:
+        CommandLineTargets.extend(tlist)
+        BuildTargets.extend(tlist)
+        BuildTargets._add_Default = BuildTargets._do_nothing
+        BuildTargets._clear = BuildTargets._do_nothing
 
 def get_calling_namespaces():
     """Return the locals and globals for the function that called
@@ -387,6 +407,26 @@ class SConsEnvironment(SCons.Environment.Base):
     # as global functions.
     #
 
+    def Default(self, *targets):
+        global DefaultCalled
+        global DefaultTargets
+        DefaultCalled = 1
+        for t in targets:
+            if t is None:
+                # Delete the elements from the list in-place, don't
+                # reassign an empty list to DefaultTargets, so that the
+                # DEFAULT_TARGETS variable will still point to the
+                # same object we point to.
+                del DefaultTargets[:]
+                BuildTargets._clear()
+            elif isinstance(t, SCons.Node.Node):
+                DefaultTargets.append(t)
+                BuildTargets._add_Default([t])
+            else:
+                nodes = self.arg2nodes(t, self.fs.Entry)
+                DefaultTargets.extend(nodes)
+                BuildTargets._add_Default(nodes)
+
     def EnsureSConsVersion(self, major, minor):
         """Exit abnormally if the SCons version is not late enough."""
         if not self._check_version(major,minor,SCons.__version__):
@@ -460,7 +500,7 @@ class SConsEnvironment(SCons.Environment.Base):
 #
 SCons.Environment.Environment = SConsEnvironment
 
-def Options(files=None, args=arguments):
+def Options(files=None, args=Arguments):
     return SCons.Options.Options(files, args)
 
 def SetBuildSignatureType(type):
@@ -545,6 +585,7 @@ class DefaultEnvironmentCall:
 # DefaultEnvironment().
 GlobalDefaultEnvironmentFunctions = [
     # Methods from the SConsEnvironment class, above.
+    'Default',
     'EnsurePythonVersion',
     'EnsureSConsVersion',
     'Exit',
@@ -566,7 +607,6 @@ GlobalDefaultEnvironmentFunctions = [
     'CacheDir',
     'Clean',
     'Command',
-    'Default',
     'Depends',
     'Dir',
     'File',
@@ -624,23 +664,31 @@ def BuildDefaultGlobals():
     SConstruct and SConscript files.
     """
 
-    globals = {}
-    globals['Action']            = SCons.Action.Action
-    globals['ARGUMENTS']         = arguments
-    globals['BoolOption']        = SCons.Options.BoolOption
-    globals['Builder']           = SCons.Builder.Builder
-    globals['Configure']         = SCons.SConf.SConf
-    globals['EnumOption']        = SCons.Options.EnumOption
-    globals['Environment']       = SCons.Environment.Environment
-    globals['ListOption']        = SCons.Options.ListOption
-    globals['Options']           = Options
-    globals['PackageOption']     = SCons.Options.PackageOption
-    globals['PathOption']        = SCons.Options.PathOption
-    globals['Platform']          = SCons.Platform.Platform
-    globals['Return']            = Return
-    globals['Scanner']           = SCons.Scanner.Base
-    globals['Tool']              = SCons.Tool.Tool
-    globals['WhereIs']           = SCons.Util.WhereIs
+    globals = {
+        # Global functions that don't get executed through the
+        # default Environment.
+        'Action'                : SCons.Action.Action,
+        'BoolOption'            : SCons.Options.BoolOption,
+        'Builder'               : SCons.Builder.Builder,
+        'Configure'             : SCons.SConf.SConf,
+        'EnumOption'            : SCons.Options.EnumOption,
+        'Environment'           : SCons.Environment.Environment,
+        'ListOption'            : SCons.Options.ListOption,
+        'Options'               : Options,
+        'PackageOption'         : SCons.Options.PackageOption,
+        'PathOption'            : SCons.Options.PathOption,
+        'Platform'              : SCons.Platform.Platform,
+        'Return'                : Return,
+        'Scanner'               : SCons.Scanner.Base,
+        'Tool'                  : SCons.Tool.Tool,
+        'WhereIs'               : SCons.Util.WhereIs,
+
+        # Other variables we provide.
+        'ARGUMENTS'             : Arguments,
+        'BUILD_TARGETS'         : BuildTargets,
+        'COMMAND_LINE_TARGETS'  : CommandLineTargets,
+        'DEFAULT_TARGETS'       : DefaultTargets,
+    }
 
     # Functions we might still convert to Environment methods.
     globals['CScan']             = SCons.Defaults.CScan
diff --git a/src/engine/SCons/Script/__init__.py b/src/engine/SCons/Script/__init__.py
index a533c29..71ed2be 100644
--- a/src/engine/SCons/Script/__init__.py
+++ b/src/engine/SCons/Script/__init__.py
@@ -753,6 +753,7 @@ def _main(args, parser):
         else:
             targets.append(a)
     SCons.Script.SConscript._scons_add_args(xmit_args)
+    SCons.Script.SConscript._scons_add_targets(targets)
 
     target_top = None
     if options.climb_up:
@@ -865,6 +866,7 @@ def _main(args, parser):
         # There are no targets specified on the command line,
         # so if they used -u, -U or -D, we may have to restrict
         # what actually gets built.
+        d = None
         if target_top:
             if options.climb_up == 1:
                 # -u, local directory and below
@@ -886,18 +888,18 @@ def _main(args, parser):
                         # or not a file, so go ahead and keep it as a default
                         # target and let the engine sort it out:
                         return 1                
-                default_targets = SCons.Environment.DefaultTargets
-                if default_targets is None:
-                    default_targets = []
-                else:
-                    default_targets = filter(check_dir, default_targets)
-                SCons.Environment.DefaultTargets = default_targets
+                d = filter(check_dir, SCons.Script.SConscript.DefaultTargets)
+                SCons.Script.SConscript.DefaultTargets[:] = d
                 target_top = None
                 lookup_top = None
 
-        targets = SCons.Environment.DefaultTargets
-        if targets is None:
-            targets = [fs.Dir('.')]
+        if SCons.Script.SConscript.DefaultCalled:
+            targets = SCons.Script.SConscript.DefaultTargets
+        else:
+            if d is None:
+                d = [fs.Dir('.')]
+            targets = d
+
 
     if not targets:
         sys.stderr.write("scons: *** No targets specified and no Default() targets found.  Stop.\n")