Pulling in hammer changes.

site_scons/site_tools/defer.py

 #!/usr/bin/python2.4
 # Copyright 2008, Google Inc.
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
@@ skipping 19 matching lines @@
 
 """Defer tool for SCons."""
 
 
 import os
 import sys
 import types
 import SCons.Errors
 
 
+# Current group name being executed by ExecuteDefer().  Set to None outside
+# of ExecuteDefer().
+_execute_defer_context = None
+
+
 class DeferGroup:
   """Named list of functions to be deferred."""
   # If we derive DeferGroup from object, instances of it return type
   # <class 'defer.DeferGroup'>, which prevents SCons.Util.semi_deepcopy()
   # from calling its __semi_deepcopy__ function.
   # TODO(sgk): Make semi_deepcopy() capable of handling classes derived from
   # object.
 
   def __init__(self):
     """Initialize deferred function object."""
@@ skipping 70 matching lines @@
   """
   return env.GetDeferRoot()['_DEFER_GROUPS']
 
 
 def ExecuteDefer(self):
   """Executes deferred functions.
 
   Args:
     self: Current environment context.
   """
+  # Check for re-entrancy
+  global _execute_defer_context
+  if _execute_defer_context:
+    raise SCons.Errors.UserError('Re-entrant call to ExecuteDefer().')
+
   # Save directory, so SConscript functions can occur in the right subdirs
   oldcwd = os.getcwd()
 
   # If defer root is set and isn't this environment, we're being called from a
   # sub-environment.  That's not where we should be called.
   if self.GetDeferRoot() != self:
     print ('Warning: Ignoring call to ExecuteDefer() from child of the '
            'environment passed to SetDeferRoot().')
     return
 
   # Get list of defer groups from ourselves.
   defer_groups = GetDeferGroups(self)
 
   # Loop through deferred functions
-  while defer_groups:
-    did_work = False
-    for name, group in defer_groups.items():
-      if group.after.intersection(defer_groups.keys()):
-        continue        # Still have dependencies
-      if group.func_env_cwd:
-        # Run all the functions in our named group
-        for func, env, cwd in group.func_env_cwd:
-          os.chdir(cwd)
-          func(env)
-      did_work = True
-      del defer_groups[name]
-      break
-    if not did_work:
-      errmsg = 'Error in ExecuteDefer: dependency cycle detected.\n'
+  try:
+    while defer_groups:
+      did_work = False
       for name, group in defer_groups.items():
-        errmsg += '   %s after: %s\n' % (name, group.after)
-      raise SCons.Errors.UserError(errmsg)
+        if group.after.intersection(defer_groups.keys()):
+          continue        # Still have dependencies
+
+        # Set defer context
+        _execute_defer_context = name
+
+        # Remove this group from the list of defer groups now, in case one of
+        # the functions it calls adds back a function into that defer group.
+        del defer_groups[name]
+
+        if group.func_env_cwd:
+          # Run all the functions in our named group
+          for func, env, cwd in group.func_env_cwd:
+            os.chdir(cwd)
+            func(env)
+
+        # The defer groups have been altered, so restart the search for
+        # functions that can be executed.
+        did_work = True
+        break
+
+      if not did_work:
+        errmsg = 'Error in ExecuteDefer: dependency cycle detected.\n'
+        for name, group in defer_groups.items():
+          errmsg += '   %s after: %s\n' % (name, group.after)
+        raise SCons.Errors.UserError(errmsg)
+  finally:
+    # No longer in a defer context
+    _execute_defer_context = None
 
   # Restore directory
   os.chdir(oldcwd)
 
 
 def PrintDefer(self, print_functions=True):
   """Prints the current defer dependency graph.
 
   Args:
     self: Environment in which PrintDefer() was called.
@@ skipping 93 matching lines @@
     defer_groups[name] = DeferGroup()
   group = defer_groups[name]
 
   # If we were given a function, also save environment and current directory
   if func:
     group.func_env_cwd.append((func, self, os.getcwd()))
 
   # Add dependencies for the function
   group.after.update(after)
 
+  # If we are already inside a call to ExecuteDefer(), any functions which are
+  # deferring until after the current function must also be deferred until
+  # after this new function.  In short, this means that if b() defers until
+  # after a() and a() calls Defer() to defer c(), then b() must also defer
+  # until after c().
+  if _execute_defer_context and name != _execute_defer_context:
+    for other_name, other_group in GetDeferGroups(self).items():
+      if other_name == name:
+        continue        # Don't defer after ourselves
+      if _execute_defer_context in other_group.after:
+        other_group.after.add(name)
+
 
 def generate(env):
   # NOTE: SCons requires the use of this name, which fails gpylint.
   """SCons entry point for this tool."""
   env.Append(_DEFER_GROUPS={})
 
   env.AddMethod(Defer)
   env.AddMethod(ExecuteDefer)
   env.AddMethod(GetDeferRoot)
   env.AddMethod(PrintDefer)
   env.AddMethod(SetDeferRoot)