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

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

 """SCons.Action
 
 This encapsulates information about executing any sort of action that
 can build one or more target Nodes (typically files) from one or more
 source Nodes (also typically files) given a specific Environment.
 
 The base class here is ActionBase.  The base class supplies just a few
 OO utility methods and some generic methods for displaying information
 about an Action in response to the various commands that control printing.
 
@@ skipping 58 matching lines @@
 There is a related independent ActionCaller class that looks like a
 regular Action, and which serves as a wrapper for arbitrary functions
 that we want to let the user specify the arguments to now, but actually
 execute later (when an out-of-date check determines that it's needed to
 be executed, for example).  Objects of this class are returned by an
 ActionFactory class that provides a __call__() method as a convenient
 way for wrapping up the functions.
 
 """
 
-# 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/Action.py 3842 2008/12/20 22:59:52 scons"
+__revision__ = "src/engine/SCons/Action.py 3897 2009/01/13 06:45:54 scons"
 
 import cPickle
 import dis
 import os
 import string
 import sys
 import subprocess
 
 from SCons.Debug import logInstanceCreation
 import SCons.Errors
@@ skipping 274 matching lines @@
     return None
 
 def _do_create_list_action(act, kw):
     """A factory for list actions.  Convert the input list into Actions
     and then wrap them in a ListAction."""
     acts = []
     for a in act:
         aa = _do_create_action(a, kw)
         if aa is not None: acts.append(aa)
     if not acts:
-        return None
+        return ListAction([])
     elif len(acts) == 1:
         return acts[0]
     else:
         return ListAction(acts)
 
 def Action(act, *args, **kw):
     """A factory for action objects."""
     # Really simple: the _do_create_* routines do the heavy lifting.
     _do_create_keywords(args, kw)
     if is_List(act):
         return _do_create_list_action(act, kw)
     return _do_create_action(act, kw)
 
 class ActionBase:
     """Base class for all types of action objects that can be held by
     other objects (Builders, Executors, etc.)  This provides the
     common methods for manipulating and combining those actions."""
 
     def __cmp__(self, other):
         return cmp(self.__dict__, other)
 
+    def no_batch_key(self, env, target, source):
+        return None
+
+    batch_key = no_batch_key
+
     def genstring(self, target, source, env):
         return str(self)
 
     def get_contents(self, target, source, env):
         result = [ self.get_presig(target, source, env) ]
         # This should never happen, as the Action() factory should wrap
         # the varlist, but just in case an action is created directly,
         # we duplicate this check here.
         vl = self.varlist
         if is_String(vl): vl = (vl,)
@@ skipping 12 matching lines @@
         # in order to return the proper string here, since
         # it may call LazyAction, which looks up a key
         # in that env.  So we temporarily remember the env here,
         # and CommandGeneratorAction will use this env
         # when it calls its _generate method.
         self.presub_env = env
         lines = string.split(str(self), '\n')
         self.presub_env = None      # don't need this any more
         return lines
 
-    def get_executor(self, env, overrides, tlist, slist, executor_kw):
-        """Return the Executor for this Action."""
-        return SCons.Executor.Executor(self, env, overrides,
-                                       tlist, slist, executor_kw)
+    def get_targets(self, env, executor):
+        """
+        Returns the type of targets ($TARGETS, $CHANGED_TARGETS) used
+        by this action.
+        """
+        return self.targets
 
 class _ActionAction(ActionBase):
     """Base class for actions that create output objects."""
     def __init__(self, cmdstr=_null, strfunction=_null, varlist=(),
                        presub=_null, chdir=None, exitstatfunc=None,
+                       batch_key=None, targets='$TARGETS',
                  **kw):
         self.cmdstr = cmdstr
         if strfunction is not _null:
             if strfunction is None:
                 self.cmdstr = None
             else:
                 self.strfunction = strfunction
         self.varlist = varlist
         self.presub = presub
         self.chdir = chdir
         if not exitstatfunc:
             exitstatfunc = default_exitstatfunc
         self.exitstatfunc = exitstatfunc
 
+        self.targets = targets
+
+        if batch_key:
+            if not callable(batch_key):
+                # They have set batch_key, but not to their own
+                # callable.  The default behavior here will batch
+                # *all* targets+sources using this action, separated
+                # for each construction environment.
+                def default_batch_key(self, env, target, source):
+                    return (id(self), id(env))
+                batch_key = default_batch_key
+            SCons.Util.AddMethod(self, batch_key, 'batch_key')
+
     def print_cmd_line(self, s, target, source, env):
         sys.stdout.write(s + "\n")
 
     def __call__(self, target, source, env,
                                exitstatfunc=_null,
                                presub=_null,
                                show=_null,
                                execute=_null,
-                               chdir=_null):
+                               chdir=_null,
+                               executor=None):
         if not is_List(target):
             target = [target]
         if not is_List(source):
             source = [source]
 
         if presub is _null:
             presub = self.presub
             if presub is _null:
                 presub = print_actions_presub
         if exitstatfunc is _null: exitstatfunc = self.exitstatfunc
         if show is _null:  show = print_actions
         if execute is _null:  execute = execute_actions
         if chdir is _null: chdir = self.chdir
         save_cwd = None
         if chdir:
             save_cwd = os.getcwd()
             try:
                 chdir = str(chdir.abspath)
             except AttributeError:
                 if not is_String(chdir):
-                    chdir = str(target[0].dir)
+                    if executor:
+                        chdir = str(executor.batches[0].targets[0].dir)
+                    else:
+                        chdir = str(target[0].dir)
         if presub:
+            if executor:
+                target = executor.get_all_targets()
+                source = executor.get_all_sources()
             t = string.join(map(str, target), ' and ')
             l = string.join(self.presub_lines(env), '\n  ')
             out = "Building %s with action:\n  %s\n" % (t, l)
             sys.stdout.write(out)
         cmd = None
         if show and self.strfunction:
-            cmd = self.strfunction(target, source, env)
+            if executor:
+                target = executor.get_all_targets()
+                source = executor.get_all_sources()
+            try:
+                cmd = self.strfunction(target, source, env, executor)
+            except TypeError:
+                cmd = self.strfunction(target, source, env)
             if cmd:
                 if chdir:
                     cmd = ('os.chdir(%s)\n' % repr(chdir)) + cmd
                 try:
                     get = env.get
                 except AttributeError:
                     print_func = self.print_cmd_line
                 else:
                     print_func = get('PRINT_CMD_LINE_FUNC')
                     if not print_func:
                         print_func = self.print_cmd_line
                 print_func(cmd, target, source, env)
         stat = 0
         if execute:
             if chdir:
                 os.chdir(chdir)
             try:
-                stat = self.execute(target, source, env)
+                stat = self.execute(target, source, env, executor=executor)
                 if isinstance(stat, SCons.Errors.BuildError):
                     s = exitstatfunc(stat.status)
                     if s:
                         stat.status = s
                     else:
                         stat = s
                 else:
                     stat = exitstatfunc(stat)
             finally:
                 if save_cwd:
@@ skipping 112 matching lines @@
             if filter(is_List, cmd):
                 raise TypeError, "CommandAction should be given only " \
                       "a single command"
         self.cmd_list = cmd
 
     def __str__(self):
         if is_List(self.cmd_list):
             return string.join(map(str, self.cmd_list), ' ')
         return str(self.cmd_list)
 
-    def process(self, target, source, env):
-        result = env.subst_list(self.cmd_list, 0, target, source)
+    def process(self, target, source, env, executor=None):
+        if executor:
+            result = env.subst_list(self.cmd_list, 0, executor=executor)
+        else:
+            result = env.subst_list(self.cmd_list, 0, target, source)
         silent = None
         ignore = None
         while 1:
             try: c = result[0][0][0]
             except IndexError: c = None
             if c == '@': silent = 1
             elif c == '-': ignore = 1
             else: break
             result[0][0] = result[0][0][1:]
         try:
             if not result[0][0]:
                 result[0] = result[0][1:]
         except IndexError:
             pass
         return result, ignore, silent
 
-    def strfunction(self, target, source, env):
+    def strfunction(self, target, source, env, executor=None):
         if self.cmdstr is None:
             return None
         if self.cmdstr is not _null:
             from SCons.Subst import SUBST_RAW
-            c = env.subst(self.cmdstr, SUBST_RAW, target, source)
+            if executor:
+                c = env.subst(self.cmdstr, SUBST_RAW, executor=executor)
+            else:
+                c = env.subst(self.cmdstr, SUBST_RAW, target, source)
             if c:
                 return c
-        cmd_list, ignore, silent = self.process(target, source, env)
+        cmd_list, ignore, silent = self.process(target, source, env, executor)
         if silent:
             return ''
         return _string_from_cmd_list(cmd_list[0])
 
-    def execute(self, target, source, env):
+    def execute(self, target, source, env, executor=None):
         """Execute a command action.
 
         This will handle lists of commands as well as individual commands,
         because construction variable substitution may turn a single
         "command" into a list.  This means that this class can actually
         handle lists of commands, even though that's not how we use it
         externally.
         """
         escape_list = SCons.Subst.escape_list
         flatten_sequence = SCons.Util.flatten_sequence
@@ skipping 24 matching lines @@
                     # value to stick in an environment variable:
                     value = flatten_sequence(value)
                     ENV[key] = string.join(map(str, value), os.pathsep)
                 else:
                     # If it isn't a string or a list, then we just coerce
                     # it to a string, which is the proper way to handle
                     # Dir and File instances and will produce something
                     # reasonable for just about everything else:
                     ENV[key] = str(value)
 
-        cmd_list, ignore, silent = self.process(target, map(rfile, source), env)
+        if executor:
+            target = executor.get_all_targets()
+            source = executor.get_all_sources()
+        cmd_list, ignore, silent = self.process(target, map(rfile, source), env, executor)
 
         # Use len() to filter out any "command" that's zero-length.
         for cmd_line in filter(len, cmd_list):
             # Escape the command line for the interpreter we are using.
             cmd_line = escape_list(cmd_line, escape)
             result = spawn(shell, escape, cmd_line[0], cmd_line, ENV)
             if not ignore and result:
                 msg = "Error %s" % result
                 return SCons.Errors.BuildError(errstr=msg,
                                                status=result,
                                                action=self,
                                                command=cmd_line)
         return 0
 
-    def get_presig(self, target, source, env):
+    def get_presig(self, target, source, env, executor=None):
         """Return the signature contents of this action's command line.
 
         This strips $(-$) and everything in between the string,
         since those parts don't affect signatures.
         """
         from SCons.Subst import SUBST_SIG
         cmd = self.cmd_list
         if is_List(cmd):
             cmd = string.join(map(str, cmd))
         else:
             cmd = str(cmd)
-        return env.subst_target_source(cmd, SUBST_SIG, target, source)
+        if executor:
+            return env.subst_target_source(cmd, SUBST_SIG, executor=executor)
+        else:
+            return env.subst_target_source(cmd, SUBST_SIG, target, source)
 
-    def get_implicit_deps(self, target, source, env):
+    def get_implicit_deps(self, target, source, env, executor=None):
         icd = env.get('IMPLICIT_COMMAND_DEPENDENCIES', True)
         if is_String(icd) and icd[:1] == '$':
             icd = env.subst(icd)
         if not icd or icd in ('0', 'None'):
             return []
         from SCons.Subst import SUBST_SIG
-        cmd_list = env.subst_list(self.cmd_list, SUBST_SIG, target, source)
+        if executor:
+            cmd_list = env.subst_list(self.cmd_list, SUBST_SIG, executor=executor)
+        else:
+            cmd_list = env.subst_list(self.cmd_list, SUBST_SIG, target, source)
         res = []
         for cmd_line in cmd_list:
             if cmd_line:
                 d = env.WhereIs(str(cmd_line[0]))
                 if d:
                     res.append(env.fs.File(d))
         return res
 
 class CommandGeneratorAction(ActionBase):
     """Class for command-generator actions."""
     def __init__(self, generator, kw):
         if __debug__: logInstanceCreation(self, 'Action.CommandGeneratorAction')
         self.generator = generator
         self.gen_kw = kw
         self.varlist = kw.get('varlist', ())
+        self.targets = kw.get('targets', '$TARGETS')
 
-    def _generate(self, target, source, env, for_signature):
+    def _generate(self, target, source, env, for_signature, executor=None):
         # ensure that target is a list, to make it easier to write
         # generator functions:
         if not is_List(target):
             target = [target]
 
-        ret = self.generator(target=target, source=source, env=env, for_signature=for_signature)
+        if executor:
+            target = executor.get_all_targets()
+            source = executor.get_all_sources()
+        ret = self.generator(target=target,
+                             source=source,
+                             env=env,
+                             for_signature=for_signature)
         #TODO(1.5) gen_cmd = Action(ret, **self.gen_kw)
         gen_cmd = apply(Action, (ret,), self.gen_kw)
         if not gen_cmd:
             raise SCons.Errors.UserError("Object returned from command generator: %s cannot be used to create an Action." % repr(ret))
         return gen_cmd
 
     def __str__(self):
         try:
             env = self.presub_env
         except AttributeError:
             env = None
         if env is None:
             env = SCons.Defaults.DefaultEnvironment()
         act = self._generate([], [], env, 1)
         return str(act)
 
-    def genstring(self, target, source, env):
-        return self._generate(target, source, env, 1).genstring(target, source, env)
+    def batch_key(self, env, target, source):
+        return self._generate(target, source, env, 1).batch_key(env, target, source)
+
+    def genstring(self, target, source, env, executor=None):
+        return self._generate(target, source, env, 1, executor).genstring(target, source, env)
 
     def __call__(self, target, source, env, exitstatfunc=_null, presub=_null,
-                 show=_null, execute=_null, chdir=_null):
-        act = self._generate(target, source, env, 0)
+                 show=_null, execute=_null, chdir=_null, executor=None):
+        act = self._generate(target, source, env, 0, executor)
+        if act is None:
+            raise UserError("While building `%s': Cannot deduce file extension from source files: %s" % (repr(map(str, target)), repr(map(str, source))))
         return act(target, source, env, exitstatfunc, presub,
-                   show, execute, chdir)
+                   show, execute, chdir, executor)
 
-    def get_presig(self, target, source, env):
+    def get_presig(self, target, source, env, executor=None):
         """Return the signature contents of this action's command line.
 
         This strips $(-$) and everything in between the string,
         since those parts don't affect signatures.
         """
-        return self._generate(target, source, env, 1).get_presig(target, source, env)
+        return self._generate(target, source, env, 1, executor).get_presig(target, source, env)
 
-    def get_implicit_deps(self, target, source, env):
-        return self._generate(target, source, env, 1).get_implicit_deps(target, source, env)
+    def get_implicit_deps(self, target, source, env, executor=None):
+        return self._generate(target, source, env, 1, executor).get_implicit_deps(target, source, env)
+
+    def get_targets(self, env, executor):
+        return self._generate(None, None, env, 1, executor).get_targets(env, executor)
 
 
 
 # A LazyAction is a kind of hybrid generator and command action for
 # strings of the form "$VAR".  These strings normally expand to other
 # strings (think "$CCCOM" to "$CC -c -o $TARGET $SOURCE"), but we also
 # want to be able to replace them with functions in the construction
 # environment.  Consequently, we want lazy evaluation and creation of
 # an Action in the case of the function, but that's overkill in the more
 # normal case of expansion to other strings.
@@ skipping 16 matching lines @@
         self.var = SCons.Util.to_String(var)
         self.gen_kw = kw
 
     def get_parent_class(self, env):
         c = env.get(self.var)
         if is_String(c) and not '\n' in c:
             return CommandAction
         return CommandGeneratorAction
 
     def _generate_cache(self, env):
-        c = env.get(self.var, '')
+        if env:
+            c = env.get(self.var, '')
+        else:
+            c = ''
         #TODO(1.5) gen_cmd = Action(c, **self.gen_kw)
         gen_cmd = apply(Action, (c,), self.gen_kw)
         if not gen_cmd:
             raise SCons.Errors.UserError("$%s value %s cannot be used to create an Action." % (self.var, repr(c)))
         return gen_cmd
 
-    def _generate(self, target, source, env, for_signature):
+    def _generate(self, target, source, env, for_signature, executor=None):
         return self._generate_cache(env)
 
     def __call__(self, target, source, env, *args, **kw):
         args = (self, target, source, env) + args
         c = self.get_parent_class(env)
         #TODO(1.5) return c.__call__(*args, **kw)
         return apply(c.__call__, args, kw)
 
     def get_presig(self, target, source, env):
         c = self.get_parent_class(env)
@@ skipping 23 matching lines @@
 
     def function_name(self):
         try:
             return self.execfunction.__name__
         except AttributeError:
             try:
                 return self.execfunction.__class__.__name__
             except AttributeError:
                 return "unknown_python_function"
 
-    def strfunction(self, target, source, env):
+    def strfunction(self, target, source, env, executor=None):
         if self.cmdstr is None:
             return None
         if self.cmdstr is not _null:
             from SCons.Subst import SUBST_RAW
-            c = env.subst(self.cmdstr, SUBST_RAW, target, source)
+            if executor:
+                c = env.subst(self.cmdstr, SUBST_RAW, executor=executor)
+            else:
+                c = env.subst(self.cmdstr, SUBST_RAW, target, source)
             if c:
                 return c
         def array(a):
             def quote(s):
                 try:
                     str_for_display = s.str_for_display
                 except AttributeError:
                     s = repr(s)
                 else:
                     s = str_for_display()
@@ skipping 12 matching lines @@
         tstr = array(target)
         sstr = array(source)
         return "%s(%s, %s)" % (name, tstr, sstr)
 
     def __str__(self):
         name = self.function_name()
         if name == 'ActionCaller':
             return str(self.execfunction)
         return "%s(target, source, env)" % name
 
-    def execute(self, target, source, env):
+    def execute(self, target, source, env, executor=None):
         exc_info = (None,None,None)
         try:
+            if executor:
+                target = executor.get_all_targets()
+                source = executor.get_all_sources()
             rsources = map(rfile, source)
             try:
                 result = self.execfunction(target=target, source=rsources, env=env)
             except KeyboardInterrupt, e:
                 raise
             except SystemExit, e:
                 raise
             except Exception, e:
                 result = e
                 exc_info = sys.exc_info()
 
             if result:
                 result = SCons.Errors.convert_to_BuildError(result, exc_info)
                 result.node=target
                 result.action=self
-                result.command=self.strfunction(target, source, env)
+                try:
+                    result.command=self.strfunction(target, source, env, executor)
+                except TypeError:
+                    result.command=self.strfunction(target, source, env)
 
                 # FIXME: This maintains backward compatibility with respect to
                 # which type of exceptions were returned by raising an
                 # exception and which ones were returned by value. It would
                 # probably be best to always return them by value here, but
                 # some codes do not check the return value of Actions and I do
                 # not have the time to modify them at this point.
                 if (exc_info[1] and
                     not isinstance(exc_info[1],EnvironmentError)):
                     raise result
@@ skipping 21 matching lines @@
     def __init__(self, list):
         if __debug__: logInstanceCreation(self, 'Action.ListAction')
         def list_of_actions(x):
             if isinstance(x, ActionBase):
                 return x
             return Action(x)
         self.list = map(list_of_actions, list)
         # our children will have had any varlist
         # applied; we don't need to do it again
         self.varlist = ()
+        self.targets = '$TARGETS'
 
     def genstring(self, target, source, env):
         return string.join(map(lambda a, t=target, s=source, e=env:
                                   a.genstring(t, s, e),
                                self.list),
                            '\n')
 
     def __str__(self):
         return string.join(map(str, self.list), '\n')
 
     def presub_lines(self, env):
         return SCons.Util.flatten_sequence(
             map(lambda a, env=env: a.presub_lines(env), self.list))
 
     def get_presig(self, target, source, env):
         """Return the signature contents of this action list.
 
         Simple concatenation of the signatures of the elements.
         """
         return string.join(map(lambda x, t=target, s=source, e=env:
                                       x.get_contents(t, s, e),
                                self.list),
                            "")
 
     def __call__(self, target, source, env, exitstatfunc=_null, presub=_null,
-                 show=_null, execute=_null, chdir=_null):
+                 show=_null, execute=_null, chdir=_null, executor=None):
+        if executor:
+            target = executor.get_all_targets()
+            source = executor.get_all_sources()
         for act in self.list:
             stat = act(target, source, env, exitstatfunc, presub,
-                       show, execute, chdir)
+                       show, execute, chdir, executor)
             if stat:
                 return stat
         return 0
 
     def get_implicit_deps(self, target, source, env):
         result = []
         for act in self.list:
             result.extend(act.get_implicit_deps(target, source, env))
         return result
 
@@ skipping 49 matching lines @@
         return map(lambda x, self=self, t=target, s=source, e=env:
                           self.subst(x, t, s, e),
                    self.args)
 
     def subst_kw(self, target, source, env):
         kw = {}
         for key in self.kw.keys():
             kw[key] = self.subst(self.kw[key], target, source, env)
         return kw
 
-    def __call__(self, target, source, env):
+    def __call__(self, target, source, env, executor=None):
         args = self.subst_args(target, source, env)
         kw = self.subst_kw(target, source, env)
         #TODO(1.5) return self.parent.actfunc(*args, **kw)
         return apply(self.parent.actfunc, args, kw)
 
     def strfunction(self, target, source, env):
         args = self.subst_args(target, source, env)
         kw = self.subst_kw(target, source, env)
         #TODO(1.5) return self.parent.strfunc(*args, **kw)
         return apply(self.parent.strfunc, args, kw)
@@ skipping 13 matching lines @@
     """
     def __init__(self, actfunc, strfunc, convert=lambda x: x):
         self.actfunc = actfunc
         self.strfunc = strfunc
         self.convert = convert
 
     def __call__(self, *args, **kw):
         ac = ActionCaller(self, args, kw)
         action = Action(ac, strfunction=ac.strfunction)
         return action