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

third_party/scons/scons-local/SCons/Taskmaster.py

 #
-# 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
@@ skipping 28 matching lines @@
         which has Task subclasses that handle its specific behavior,
         like printing "`foo' is up to date" when a top-level target
         doesn't need to be built, and handling the -c option by removing
         targets as its "build" action.  There is also a separate subclass
         for suppressing this output when the -q option is used.
 
         The Taskmaster instantiates a Task object for each (set of)
         target(s) that it decides need to be evaluated and/or built.
 """
 
-__revision__ = "src/engine/SCons/Taskmaster.py 3842 2008/12/20 22:59:52 scons"
+__revision__ = "src/engine/SCons/Taskmaster.py 3897 2009/01/13 06:45:54 scons"
 
 from itertools import chain
 import operator
 import string
 import sys
 import traceback
 
 import SCons.Errors
 import SCons.Node
+import SCons.Warnings
 
 StateString = SCons.Node.StateString
 NODE_NO_STATE = SCons.Node.no_state
 NODE_PENDING = SCons.Node.pending
 NODE_EXECUTING = SCons.Node.executing
 NODE_UP_TO_DATE = SCons.Node.up_to_date
 NODE_EXECUTED = SCons.Node.executed
 NODE_FAILED = SCons.Node.failed
 
 
@@ skipping 107 matching lines @@
         # Let the targets take care of any necessary preparations.
         # This includes verifying that all of the necessary sources
         # and dependencies exist, removing the target file(s), etc.
         #
         # As of April 2008, the get_executor().prepare() method makes
         # sure that all of the aggregate sources necessary to build this
         # Task's target(s) exist in one up-front check.  The individual
         # target t.prepare() methods check that each target's explicit
         # or implicit dependencies exists, and also initialize the
         # .sconsign info.
-        self.targets[0].get_executor().prepare()
-        for t in self.targets:
+        executor = self.targets[0].get_executor()
+        executor.prepare()
+        for t in executor.get_action_targets():
             t.prepare()
             for s in t.side_effects:
                 s.prepare()
 
     def get_target(self):
         """Fetch the target being built or updated by this task.
         """
         return self.node
 
     def needs_execute(self):
-        """
-        Called to determine whether the task's execute() method should
-        be run.
-
-        This method allows one to skip the somethat costly execution
-        of the execute() method in a seperate thread. For example,
-        that would be unnecessary for up-to-date targets.
-        """
+        # TODO(deprecate):  "return True" is the old default behavior;
+        # change it to NotImplementedError (after running through the
+        # Deprecation Cycle) so the desired behavior is explicitly
+        # determined by which concrete subclass is used.
+        #raise NotImplementedError
+        msg = ('Direct use of the Taskmaster.Task class will be deprecated\n'
+               + '\tin a future release.')
+        SCons.Warnings.warn(SCons.Warnings.TaskmasterNeedsExecuteWarning, msg)
         return True
 
     def execute(self):
         """
         Called to execute the task.
 
         This method is called from multiple threads in a parallel build,
         so only do thread safe stuff here.  Do thread unsafe stuff in
         prepare(), executed() or failed().
         """
@@ skipping 276 matching lines @@
         Task ready for execution.
         """
         exc = self.exc_info()[:]
         try:
             exc_type, exc_value, exc_traceback = exc
         except ValueError:
             exc_type, exc_value = exc
             exc_traceback = None
         raise exc_type, exc_value, exc_traceback
 
+class AlwaysTask(Task):
+    def needs_execute(self):
+        """
+        Always returns True (indicating this Task should always
+        be executed).
+
+        Subclasses that need this behavior (as opposed to the default
+        of only executing Nodes that are out of date w.r.t. their
+        dependencies) can use this as follows:
+
+            class MyTaskSubclass(SCons.Taskmaster.Task):
+                needs_execute = SCons.Taskmaster.Task.execute_always
+        """
+        return True
+
+class OutOfDateTask(Task):
+    def needs_execute(self):
+        """
+        Returns True (indicating this Task should be executed) if this
+        Task's target state indicates it needs executing, which has
+        already been determined by an earlier up-to-date check.
+        """
+        return self.targets[0].get_state() == SCons.Node.executing
+
 
 def find_cycle(stack, visited):
     if stack[-1] in visited:
         return None
     visited.add(stack[-1])
     for n in stack[-1].waiting_parents:
         stack.append(n)
         if stack[0] == stack[-1]:
             return stack
         if find_cycle(stack, visited):
             return stack
         stack.pop()
     return None
 
 
 class Taskmaster:
     """
     The Taskmaster for walking the dependency DAG.
     """
 
-    def __init__(self, targets=[], tasker=Task, order=None, trace=None):
+    def __init__(self, targets=[], tasker=None, order=None, trace=None):
         self.original_top = targets
         self.top_targets_left = targets[:]
         self.top_targets_left.reverse()
         self.candidates = []
+        if tasker is None:
+            tasker = OutOfDateTask
         self.tasker = tasker
         if not order:
             order = lambda l: l
         self.order = order
         self.message = None
         self.trace = trace
         self.next_candidate = self.find_next_candidate
         self.pending_children = set()
 
     def find_next_candidate(self):
@@ skipping 190 matching lines @@
 
             if state == NODE_NO_STATE:
                 # Mark this node as being on the execution stack:
                 node.set_state(NODE_PENDING)
             elif state > NODE_PENDING:
                 # Skip this node if it has already been evaluated:
                 if S: S.already_handled = S.already_handled + 1
                 if T: T.write(self.trace_message('       already handled (executed)'))
                 continue
 
+            executor = node.get_executor()
+
             try:
-                children = node.children()
+                children = executor.get_all_children()
             except SystemExit:
                 exc_value = sys.exc_info()[1]
                 e = SCons.Errors.ExplicitExit(node, exc_value.code)
                 self.ready_exc = (SCons.Errors.ExplicitExit, e)
                 if T: T.write(self.trace_message('       SystemExit'))
                 return node
             except Exception, e:
                 # We had a problem just trying to figure out the
                 # children (like a child couldn't be linked in to a
                 # VariantDir, or a Scanner threw something).  Arrange to
                 # raise the exception when the Task is "executed."
                 self.ready_exc = sys.exc_info()
                 if S: S.problem = S.problem + 1
                 if T: T.write(self.trace_message('       exception %s while scanning children.\n' % e))
                 return node
 
             children_not_visited = []
             children_pending = set()
             children_not_ready = []
             children_failed = False
 
-            for child in chain(children,node.prerequisites):
+            for child in chain(children, executor.get_all_prerequisites()):
                 childstate = child.get_state()
 
                 if T: T.write(self.trace_message('       ' + self.trace_node(child)))
 
                 if childstate == NODE_NO_STATE:
                     children_not_visited.append(child)
                 elif childstate == NODE_PENDING:
                     children_pending.add(child)
                 elif childstate == NODE_FAILED:
                     children_failed = True
@@ skipping 23 matching lines @@
             # target, the next time occurs through the other target.
             #
             # Note that we can only have failed_children if the
             # --keep-going flag was used, because without it the build
             # will stop before diving in the other branch.
             #
             # Note that even if one of the children fails, we still
             # added the other children to the list of candidate nodes
             # to keep on building (--keep-going).
             if children_failed:
-                node.set_state(NODE_FAILED)
+                for n in executor.get_action_targets():
+                    n.set_state(NODE_FAILED)
 
                 if S: S.child_failed = S.child_failed + 1
                 if T: T.write(self.trace_message('****** %s\n' % self.trace_node(node)))
                 continue
 
             if children_not_ready:
                 for child in children_not_ready:
                     # We're waiting on one or more derived targets
                     # that have not yet finished building.
                     if S: S.not_built = S.not_built + 1
@@ skipping 10 matching lines @@
                     for pc in children_pending:
                         T.write(self.trace_message('       adding %s to the pending children set\n' %
                                 self.trace_node(pc)))
                 self.pending_children = self.pending_children | children_pending
 
                 continue
 
             # Skip this node if it has side-effects that are
             # currently being built:
             wait_side_effects = False
-            for se in node.side_effects:
+            for se in executor.get_action_side_effects():
                 if se.get_state() == NODE_EXECUTING:
                     se.add_to_waiting_s_e(node)
                     wait_side_effects = True
 
             if wait_side_effects:
                 if S: S.side_effects = S.side_effects + 1
                 continue
 
             # The default when we've gotten through all of the checks above:
             # this node is ready to be built.
@@ skipping 18 matching lines @@
         Returns the next task to be executed.
 
         This simply asks for the next Node to be evaluated, and then wraps
         it in the specific Task subclass with which we were initialized.
         """
         node = self._find_next_ready_node()
 
         if node is None:
             return None
 
-        tlist = node.get_executor().targets
+        tlist = node.get_executor().get_all_targets()
 
         task = self.tasker(self, tlist, node in self.original_top, node)
         try:
             task.make_ready()
         except:
             # We had a problem just trying to get this task ready (like
             # a child couldn't be linked in to a VariantDir when deciding
             # whether this node is current).  Arrange to raise the
             # exception when the Task is "executed."
             self.ready_exc = sys.exc_info()
@@ skipping 89 matching lines @@
         desc = 'Found dependency cycle(s):\n'
         for node, cycle in nclist:
             if cycle:
                 desc = desc + "  " + string.join(map(str, cycle), " -> ") + "\n"
             else:
                 desc = desc + \
                     "  Internal Error: no cycle found for node %s (%s) in state %s\n" %  \
                     (node, repr(node), StateString[node.get_state()])
 
         raise SCons.Errors.UserError, desc