Update to SCons 1.2.0.

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.
@@ skipping 16 matching lines @@
 #
 # 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 3603 2008/10/10 05:46:45 scons"
+__revision__ = "src/engine/SCons/Script/Main.py 3842 2008/12/20 22:59:52 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 161 matching lines @@
         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)
         else:
             SCons.Taskmaster.Task.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.
-        status = 2
         exc_info = self.exc_info()
         try:
             t, e, tb = exc_info
         except ValueError:
             t, e = exc_info
             tb = None
+
         if t is None:
             # The Taskmaster didn't record an exception for this Task;
             # see if the sys module has one.
-            t, e = sys.exc_info()[:2]
+            try:
+                t, e, tb = sys.exc_info()[:]
+            except ValueError:
+                t, e = exc_info
+                tb = None
+                
+        # Deprecated string exceptions will have their string stored
+        # in the first entry of the tuple.
+        if e is None:
+            e = t
 
-        def nodestring(n):
-            if not SCons.Util.is_List(n):
-                n = [ n ]
-            return string.join(map(str, n), ', ')
+        buildError = SCons.Errors.convert_to_BuildError(e)
+        if not buildError.node:
+            buildError.node = self.node
+
+        node = buildError.node
+        if not SCons.Util.is_List(node):
+                node = [ node ]
+        nodename = string.join(map(str, node), ', ')
 
         errfmt = "scons: *** [%s] %s\n"
+        sys.stderr.write(errfmt % (nodename, buildError))
 
-        if t == SCons.Errors.BuildError:
-            tname = nodestring(e.node)
-            errstr = e.errstr
-            if e.filename:
-                errstr = e.filename + ': ' + errstr
-            sys.stderr.write(errfmt % (tname, errstr))
-        elif t == SCons.Errors.TaskmasterException:
-            tname = nodestring(e.node)
-            sys.stderr.write(errfmt % (tname, e.errstr))
-            type, value, trace = e.exc_info
+        if (buildError.exc_info[2] and buildError.exc_info[1] and 
+           # TODO(1.5)
+           #not isinstance(
+           #    buildError.exc_info[1], 
+           #    (EnvironmentError, SCons.Errors.StopError, SCons.Errors.UserError))):
+           not isinstance(buildError.exc_info[1], EnvironmentError) and
+           not isinstance(buildError.exc_info[1], SCons.Errors.StopError) and
+           not isinstance(buildError.exc_info[1], SCons.Errors.UserError)):
+            type, value, trace = buildError.exc_info
             traceback.print_exception(type, value, trace)
-        elif t == SCons.Errors.ExplicitExit:
-            status = e.status
-            tname = nodestring(e.node)
-            errstr = 'Explicit exit, status %s' % status
-            sys.stderr.write(errfmt % (tname, errstr))
-        else:
-            if e is None:
-                e = t
-            s = str(e)
-            if t == SCons.Errors.StopError and not self.options.keep_going:
-                s = s + '  Stop.'
-            sys.stderr.write("scons: *** %s\n" % s)
+        elif tb and print_stacktrace:
+            sys.stderr.write("scons: internal stack trace:\n")
+            traceback.print_tb(tb, file=sys.stderr)
 
-            if tb and print_stacktrace:
-                sys.stderr.write("scons: internal stack trace:\n")
-                traceback.print_tb(tb, file=sys.stderr)
-
-        self.do_failed(status)
+        self.exception = (e, buildError, tb) # type, value, traceback
+        self.do_failed(buildError.exitstatus)
 
         self.exc_clear()
 
     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()
@@ skipping 301 matching lines @@
     sys.stderr.write('File "%s", line %d, in %s\n' % (filename, lineno, routine))
 
 def _scons_internal_error():
     """Handle all errors but user errors. Print out a message telling
     the user what to do in this case and print a normal trace.
     """
     print 'internal error'
     traceback.print_exc()
     sys.exit(2)
 
-def _SConstruct_exists(dirname='', repositories=[]):
+def _SConstruct_exists(dirname='', repositories=[], filelist=None):
     """This function checks that an SConstruct file exists in a directory.
     If so, it returns the path of the file. By default, it checks the
     current directory.
     """
-    for file in ['SConstruct', 'Sconstruct', 'sconstruct']:
+    if not filelist:
+        filelist = ['SConstruct', 'Sconstruct', 'sconstruct']
+    for file in filelist:
         sfile = os.path.join(dirname, file)
         if os.path.isfile(sfile):
             return sfile
         if not os.path.isabs(sfile):
             for rep in repositories:
                 if os.path.isfile(os.path.join(rep, sfile)):
                     return sfile
     return None
 
 def _set_debug_values(options):
@@ skipping 108 matching lines @@
     # Here's where everything really happens.
 
     # First order of business:  set up default warnings and then
     # handle the user's warning options, so that we can issue (or
     # suppress) appropriate warnings about anything that might happen,
     # as configured by the user.
 
     default_warnings = [ SCons.Warnings.CorruptSConsignWarning,
                          SCons.Warnings.DeprecatedWarning,
                          SCons.Warnings.DuplicateEnvironmentWarning,
+                         SCons.Warnings.FutureReservedVariableWarning,
                          SCons.Warnings.LinkWarning,
                          SCons.Warnings.MissingSConscriptWarning,
                          SCons.Warnings.NoMD5ModuleWarning,
                          SCons.Warnings.NoMetaclassSupportWarning,
                          SCons.Warnings.NoObjectCountWarning,
                          SCons.Warnings.NoParallelSupportWarning,
                          SCons.Warnings.MisleadingKeywordsWarning,
-                         SCons.Warnings.StackSizeWarning, ]
+                         SCons.Warnings.ReservedVariableWarning,
+                         SCons.Warnings.StackSizeWarning,
+                       ]
 
     for warning in default_warnings:
         SCons.Warnings.enableWarningClass(warning)
     SCons.Warnings._warningOut = _scons_internal_warning
     SCons.Warnings.process_warn_strings(options.warn)
 
     # Now that we have the warnings configuration set up, we can actually
     # issue (or suppress) any warnings about warning-worthy things that
     # occurred while the command-line options were getting parsed.
     try:
@@ skipping 17 matching lines @@
         cdir = _create_path(options.directory)
         try:
             os.chdir(cdir)
         except OSError:
             sys.stderr.write("Could not change directory to %s\n" % cdir)
 
     target_top = None
     if options.climb_up:
         target_top = '.'  # directory to prepend to targets
         script_dir = os.getcwd()  # location of script
-        while script_dir and not _SConstruct_exists(script_dir, options.repository):
+        while script_dir and not _SConstruct_exists(script_dir,
+                                                    options.repository,
+                                                    options.file):
             script_dir, last_part = os.path.split(script_dir)
             if last_part:
                 target_top = os.path.join(last_part, target_top)
             else:
                 script_dir = ''
-        if script_dir:
+        if script_dir and script_dir != os.getcwd():
             display("scons: Entering directory `%s'" % script_dir)
             os.chdir(script_dir)
 
     # Now that we're in the top-level SConstruct directory, go ahead
     # and initialize the FS object that represents the file system,
     # and make it the build engine default.
     fs = SCons.Node.FS.get_default_fs()
 
     for rep in options.repository:
         fs.Repository(rep)
 
     # Now that we have the FS object, the next order of business is to
     # check for an SConstruct file (or other specified config file).
     # If there isn't one, we can bail before doing any more work.
     scripts = []
     if options.file:
         scripts.extend(options.file)
     if not scripts:
-        sfile = _SConstruct_exists(repositories=options.repository)
+        sfile = _SConstruct_exists(repositories=options.repository,
+                                   filelist=options.file)
         if sfile:
             scripts.append(sfile)
 
     if not scripts:
         if options.help:
             # There's no SConstruct, but they specified -h.
             # Give them the options usage now, before we fail
             # trying to read a non-existent SConstruct file.
             raise SConsPrintHelpException
         raise SCons.Errors.UserError, "No SConstruct file found."
@@ skipping 443 matching lines @@
         sys.exit(2)
     except SyntaxError, e:
         _scons_syntax_error(e)
     except SCons.Errors.InternalError:
         _scons_internal_error()
     except SCons.Errors.UserError, e:
         _scons_user_error(e)
     except SConsPrintHelpException:
         parser.print_help()
         exit_status = 0
+    except SCons.Errors.BuildError, e:
+        exit_status = e.exitstatus
     except:
         # An exception here is likely a builtin Python exception Python
         # code in an SConscript file.  Show them precisely what the
         # problem was and where it happened.
         SCons.Script._SConscript.SConscript_exception()
         sys.exit(2)
 
     memory_stats.print_stats()
     count_stats.print_stats()
 
@@ skipping 20 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)