Really support strfunction for all Action subclasses by refactoring the interface between Executor and Action, and collecting all the print/execute logic in a single ActionBase.__call__() method.

4 files changed, 22 insertions, 38 deletions

diff --git a/src/engine/SCons/Node/FS.py b/src/engine/SCons/Node/FS.py
index a30994d..008976b 100644
--- a/src/engine/SCons/Node/FS.py
+++ b/src/engine/SCons/Node/FS.py
@@ -1476,7 +1476,7 @@ class File(Base):
         listDirs.reverse()
         for dirnode in listDirs:
             try:
-                Mkdir(dirnode, None, None)
+                Mkdir(dirnode, [], None)
                 # The Mkdir() action may or may not have actually
                 # created the directory, depending on whether the -n
                 # option was used or not.  Delete the _exists and
@@ -1506,17 +1506,10 @@ class File(Base):
             return None
         if b and self.fs.CachePath:
             if self.fs.cache_show:
-                if CacheRetrieveSilent(self, None, None) == 0:
-                    def do_print(action, targets, sources, env, s=self):
-                        if action.strfunction:
-                            al = action.strfunction(targets, s.sources, env)
-                            if not SCons.Util.is_List(al):
-                                al = [al]
-                            for a in al:
-                                action.show(a)
-                    self._for_each_action(do_print)
+                if CacheRetrieveSilent(self, [], None) == 0:
+                    self.build(presub=0, execute=0)
                     return 1
-            elif CacheRetrieve(self, None, None) == 0:
+            elif CacheRetrieve(self, [], None) == 0:
                 return 1
         return None
 
@@ -1526,7 +1519,7 @@ class File(Base):
         # method has a chance to clear the build signature, which it
         # will do if this file has a source scanner.
         if self.fs.CachePath and self.fs.exists(self.path):
-            CachePush(self, None, None)
+            CachePush(self, [], None)
         SCons.Node.Node.built(self)
         self.found_includes = {}
         try:
@@ -1596,7 +1589,7 @@ class File(Base):
             if self.exists():
                 if self.is_derived() and not self.precious:
                     try:
-                        Unlink(self, None, None)
+                        Unlink(self, [], None)
                     except OSError, e:
                         raise SCons.Errors.BuildError(node = self,
                                                       errstr = e.strerror)
diff --git a/src/engine/SCons/Node/FSTests.py b/src/engine/SCons/Node/FSTests.py
index d5e04e1..9a5be45 100644
--- a/src/engine/SCons/Node/FSTests.py
+++ b/src/engine/SCons/Node/FSTests.py
@@ -76,9 +76,10 @@ class Environment:
         pass
 
 class Action:
-    def __call__(self, targets, sources, env):
+    def __call__(self, targets, sources, env, errfunc, **kw):
         global built_it
-        built_it = 1
+        if kw.get('execute', 1):
+            built_it = 1
         return 0
     def show(self, string):
         pass
diff --git a/src/engine/SCons/Node/NodeTests.py b/src/engine/SCons/Node/NodeTests.py
index 4ea73ab..7a6c39a 100644
--- a/src/engine/SCons/Node/NodeTests.py
+++ b/src/engine/SCons/Node/NodeTests.py
@@ -43,7 +43,7 @@ class MyAction:
     def __init__(self):
         self.order = 0
 
-    def __call__(self, target, source, env):
+    def __call__(self, target, source, env, errfunc):
         global built_it, built_target, built_source, built_args, built_order
         built_it = 1
         built_target = target
@@ -63,7 +63,7 @@ class MyNonGlobalAction:
         self.built_target =  None
         self.built_source =  None
 
-    def __call__(self, target, source, env):
+    def __call__(self, target, source, env, errfunc):
         # Okay, so not ENTIRELY non-global...
         global built_order
         self.built_it = 1
@@ -166,6 +166,8 @@ class NodeTestCase(unittest.TestCase):
         node = MyNode("www")
         node.build()
         assert built_it == None
+        node.build(extra_kw_argument = 1)
+        assert built_it == None
 
         node = MyNode("xxx")
         node.builder_set(Builder())
diff --git a/src/engine/SCons/Node/__init__.py b/src/engine/SCons/Node/__init__.py
index 9897d1a..9a4162c 100644
--- a/src/engine/SCons/Node/__init__.py
+++ b/src/engine/SCons/Node/__init__.py
@@ -161,26 +161,14 @@ class Node:
             if not create:
                 raise
             import SCons.Executor
-            executor = SCons.Executor.Executor(self.builder,
+            executor = SCons.Executor.Executor(self.builder.action,
                                                self.builder.env,
-                                               {},
+                                               [self.builder.overrides],
                                                [self],
                                                self.sources)
             self.executor = executor
         return executor
 
-    def _for_each_action(self, func):
-        """Call a function for each action required to build a node.
-
-        The purpose here is to have one place for the logic that
-        collects and executes all of the actions for a node's builder,
-        even though multiple sections of code elsewhere need this logic
-        to do different things."""
-        if not self.has_builder():
-            return
-        executor = self.get_executor()
-        executor(self, func)
-
     def retrieve_from_cache(self):
         """Try to retrieve the node's content from a cache
 
@@ -192,19 +180,19 @@ class Node:
         """
         return 0
         
-    def build(self):
+    def build(self, **kw):
         """Actually build the node.
 
         This method is called from multiple threads in a parallel build,
         so only do thread safe stuff here. Do thread unsafe stuff in
         built().
         """
-        def do_action(action, targets, sources, env, s=self):
-            stat = action(targets, sources, env)
-            if stat:
-                raise SCons.Errors.BuildError(node = s,
-                                              errstr = "Error %d" % stat)
-        self._for_each_action(do_action)
+        if not self.has_builder():
+            return
+        def errfunc(stat, node=self):
+            raise SCons.Errors.BuildError(node=node, errstr="Error %d" % stat)
+        executor = self.get_executor()
+        apply(executor, (self, errfunc), kw)
 
     def built(self):
         """Called just after this node is sucessfully built."""