Update SCons to latest checkpoint release, 1.2.0.d20090113....

third_party/scons/scons-local/SCons/Script/Main.py

 """SCons.Script
 
 This file implements the main() function used by the scons script.
 
 Architecturally, this *is* the scons script, and will likely only be
 called from the external "scons" wrapper.  Consequently, anything here
 should not be, or be considered, part of the build engine.  If it's
 something that we expect other software to want to use, it should go in
 some other module.  If it's specific to the "scons" script invocation,
 it goes here.
 
 """
 
 #
-# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation
+# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish,
 # distribute, sublicense, and/or sell copies of the Software, and to
 # permit persons to whom the Software is furnished to do so, subject to
 # the following conditions:
 #
 # The above copyright notice and this permission notice shall be included
 # in all copies or substantial portions of the Software.
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
 
-__revision__ = "src/engine/SCons/Script/Main.py 3842 2008/12/20 22:59:52 scons"
+__revision__ = "src/engine/SCons/Script/Main.py 3897 2009/01/13 06:45:54 scons"
 
 import os
 import os.path
 import string
 import sys
 import time
 import traceback
 
 # Strip the script directory from sys.path() so on case-insensitive
 # (Windows) systems Python doesn't think that the "scons" script is the
@@ skipping 100 matching lines @@
     ProgressObject = apply(Progressor, args, kw)
 
 # Task control.
 #
 
 _BuildFailures = []
 
 def GetBuildFailures():
     return _BuildFailures
 
-class BuildTask(SCons.Taskmaster.Task):
+class BuildTask(SCons.Taskmaster.OutOfDateTask):
     """An SCons build task."""
     progress = ProgressObject
 
     def display(self, message):
         display('scons: ' + message)
 
     def prepare(self):
         self.progress(self.targets[0])
-        return SCons.Taskmaster.Task.prepare(self)
+        return SCons.Taskmaster.OutOfDateTask.prepare(self)
 
     def needs_execute(self):
-        target = self.targets[0]
-        if target.get_state() == SCons.Node.executing:
+        if SCons.Taskmaster.OutOfDateTask.needs_execute(self):
             return True
-        else:
-            if self.top and target.has_builder():
-                display("scons: `%s' is up to date." % str(self.node))
-            return False
+        if self.top and self.targets[0].has_builder():
+            display("scons: `%s' is up to date." % str(self.node))
+        return False
 
     def execute(self):
         if print_time:
             start_time = time.time()
             global first_command_start
             if first_command_start is None:
                 first_command_start = start_time
-        SCons.Taskmaster.Task.execute(self)
+        SCons.Taskmaster.OutOfDateTask.execute(self)
         if print_time:
             global cumulative_command_time
             global last_command_end
             finish_time = time.time()
             last_command_end = finish_time
             cumulative_command_time = cumulative_command_time+finish_time-start_time
             sys.stdout.write("Command execution time: %f seconds\n"%(finish_time-start_time))
 
     def do_failed(self, status=2):
         _BuildFailures.append(self.exception[1])
         global exit_status
         global this_build_status
         if self.options.ignore_errors:
-            SCons.Taskmaster.Task.executed(self)
+            SCons.Taskmaster.OutOfDateTask.executed(self)
         elif self.options.keep_going:
-            SCons.Taskmaster.Task.fail_continue(self)
+            SCons.Taskmaster.OutOfDateTask.fail_continue(self)
             exit_status = status
             this_build_status = status
         else:
-            SCons.Taskmaster.Task.fail_stop(self)
+            SCons.Taskmaster.OutOfDateTask.fail_stop(self)
             exit_status = status
             this_build_status = status
             
     def executed(self):
         t = self.targets[0]
         if self.top and not t.has_builder() and not t.side_effect:
             if not t.exists():
                 errstr="Do not know how to make target `%s'." % t
                 sys.stderr.write("scons: *** " + errstr)
                 if not self.options.keep_going:
                     sys.stderr.write("  Stop.")
                 sys.stderr.write("\n")
                 try:
                     raise SCons.Errors.BuildError(t, errstr)
                 except KeyboardInterrupt:
                     raise
                 except:
                     self.exception_set()
                 self.do_failed()
             else:
                 print "scons: Nothing to be done for `%s'." % t
-                SCons.Taskmaster.Task.executed(self)
+                SCons.Taskmaster.OutOfDateTask.executed(self)
         else:
-            SCons.Taskmaster.Task.executed(self)
+            SCons.Taskmaster.OutOfDateTask.executed(self)
 
     def failed(self):
         # Handle the failure of a build task.  The primary purpose here
         # is to display the various types of Errors and Exceptions
         # appropriately.
         exc_info = self.exc_info()
         try:
             t, e, tb = exc_info
         except ValueError:
             t, e = exc_info
@@ skipping 47 matching lines @@
     def postprocess(self):
         if self.top:
             t = self.targets[0]
             for tp in self.options.tree_printers:
                 tp.display(t)
             if self.options.debug_includes:
                 tree = t.render_include_tree()
                 if tree:
                     print
                     print tree
-        SCons.Taskmaster.Task.postprocess(self)
+        SCons.Taskmaster.OutOfDateTask.postprocess(self)
 
     def make_ready(self):
         """Make a task ready for execution"""
-        SCons.Taskmaster.Task.make_ready(self)
+        SCons.Taskmaster.OutOfDateTask.make_ready(self)
         if self.out_of_date and self.options.debug_explain:
             explanation = self.out_of_date[0].explain()
             if explanation:
                 sys.stdout.write("scons: " + explanation)
 
-class CleanTask(SCons.Taskmaster.Task):
+class CleanTask(SCons.Taskmaster.AlwaysTask):
     """An SCons clean task."""
     def fs_delete(self, path, pathstr, remove=1):
         try:
             if os.path.exists(path):
                 if os.path.isfile(path):
                     if remove: os.unlink(path)
                     display("Removed " + pathstr)
                 elif os.path.isdir(path) and not os.path.islink(path):
                     # delete everything in the dir
                     entries = os.listdir(path)
@@ skipping 55 matching lines @@
     executed = SCons.Taskmaster.Task.executed_without_callbacks
 
     # Have the taskmaster arrange to "execute" all of the targets, because
     # we'll figure out ourselves (in remove() or show() above) whether
     # anything really needs to be done.
     make_ready = SCons.Taskmaster.Task.make_ready_all
 
     def prepare(self):
         pass
 
-class QuestionTask(SCons.Taskmaster.Task):
+class QuestionTask(SCons.Taskmaster.AlwaysTask):
     """An SCons task for the -q (question) option."""
     def prepare(self):
         pass
-    
+
     def execute(self):
         if self.targets[0].get_state() != SCons.Node.up_to_date or \
            (self.top and not self.targets[0].exists()):
             global exit_status
             global this_build_status
             exit_status = 1
             this_build_status = 1
             self.tm.stop()
 
     def executed(self):
@@ skipping 762 matching lines @@
     memory_stats.append('before building targets:')
     count_stats.append(('pre-', 'build'))
 
     def jobs_postfunc(
         jobs=jobs,
         options=options,
         closing_message=closing_message,
         failure_message=failure_message
         ):
         if jobs.were_interrupted():
-            progress_display("scons: Build interrupted.")
+            if not options.no_progress and not options.silent:
+                sys.stderr.write("scons: Build interrupted.\n")
             global exit_status
             global this_build_status
             exit_status = 2
             this_build_status = 2
 
         if this_build_status:
             progress_display("scons: " + failure_message)
         else:
             progress_display("scons: " + closing_message)
         if not options.no_exec:
@@ skipping 64 matching lines @@
 
     parts = ["SCons by Steven Knight et al.:\n"]
     try:
         import __main__
         parts.append(version_string("script", __main__))
     except (ImportError, AttributeError):
         # On Windows there is no scons.py, so there is no
         # __main__.__version__, hence there is no script version.
         pass 
     parts.append(version_string("engine", SCons))
-    parts.append("Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation")
+    parts.append("Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation")
     version = string.join(parts, '')
 
     import SConsOptions
     parser = SConsOptions.Parser(version)
     values = SConsOptions.SConsValues(parser.get_default_values())
 
     OptionsParser = parser
     
     try:
         _exec_main(parser, values)
@@ skipping 47 matching lines @@
                 ct = 0.0
             else:
                 ct = last_command_end - first_command_start
         scons_time = total_time - sconscript_time - ct
         print "Total build time: %f seconds"%total_time
         print "Total SConscript file execution time: %f seconds"%sconscript_time
         print "Total SCons execution time: %f seconds"%scons_time
         print "Total command execution time: %f seconds"%ct
 
     sys.exit(exit_status)