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

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

 """SCons.Builder
 
 Builder object subsystem.
 
 A Builder object is a callable that encapsulates information about how
 to execute actions to create a target Node (file) from source Nodes
 (files), and how to create those dependencies for tracking.
 
 The main entry point here is the Builder() factory method.  This provides
 a procedural interface that creates the right underlying Builder object
@@ skipping 58 matching lines @@
     get_suffix()
     get_src_suffix()
     set_src_suffix()
         Miscellaneous stuff for handling the prefix and suffix
         manipulation we use in turning source file names into target
         file names.
 
 """
 
 #
-# 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/Builder.py 3842 2008/12/20 22:59:52 scons"
+__revision__ = "src/engine/SCons/Builder.py 3897 2009/01/13 06:45:54 scons"
 
 import UserDict
 import UserList
 
 import SCons.Action
 from SCons.Debug import logInstanceCreation
 from SCons.Errors import InternalError, UserError
 import SCons.Executor
 import SCons.Memoize
 import SCons.Node
 import SCons.Node.FS
 import SCons.Util
 import SCons.Warnings
 
 class _Null:
     pass
 
 _null = _Null
 
+def match_splitext(path, suffixes = []):
+    if suffixes:
+        matchsuf = filter(lambda S,path=path: path[-len(S):] == S,
+                          suffixes)
+        if matchsuf:
+            suf = max(map(None, map(len, matchsuf), matchsuf))[1]
+            return [path[:-len(suf)], path[-len(suf):]]
+    return SCons.Util.splitext(path)
+
 class DictCmdGenerator(SCons.Util.Selector):
     """This is a callable class that can be used as a
     command generator function.  It holds on to a dictionary
     mapping file suffixes to Actions.  It uses that dictionary
     to return the proper action based on the file suffix of
     the source file."""
 
     def __init__(self, dict=None, source_ext_match=1):
         SCons.Util.Selector.__init__(self, dict)
         self.source_ext_match = source_ext_match
 
     def src_suffixes(self):
         return self.keys()
 
     def add_action(self, suffix, action):
         """Add a suffix-action pair to the mapping.
         """
         self[suffix] = action
 
     def __call__(self, target, source, env, for_signature):
         if not source:
             return []
 
         if self.source_ext_match:
+            suffixes = self.src_suffixes()
             ext = None
             for src in map(str, source):
-                my_ext = SCons.Util.splitext(src)[1]
+                my_ext = match_splitext(src, suffixes)[1]
                 if ext and my_ext != ext:
                     raise UserError("While building `%s' from `%s': Cannot build multiple sources with different extensions: %s, %s" % (repr(map(str, target)), src, ext, my_ext))
                 ext = my_ext
         else:
-            ext = SCons.Util.splitext(str(source[0]))[1]
+            ext = match_splitext(str(source[0]), self.src_suffixes())[1]
 
         if not ext:
+            #return ext
             raise UserError("While building `%s': Cannot deduce file extension from source files: %s" % (repr(map(str, target)), repr(map(str, source))))
 
         try:
-            ret = SCons.Util.Selector.__call__(self, env, source)
+            ret = SCons.Util.Selector.__call__(self, env, source, ext)
         except KeyError, e:
             raise UserError("Ambiguous suffixes after environment substitution: %s == %s == %s" % (e[0], e[1], e[2]))
         if ret is None:
             raise UserError("While building `%s' from `%s': Don't know how to build from a source file with suffix `%s'.  Expected a suffix in this list: %s." % \
                             (repr(map(str, target)), repr(map(str, source)), ext, repr(self.keys())))
         return ret
 
 class CallableSelector(SCons.Util.Selector):
     """A callable dictionary that will, in turn, call the value it
     finds if it can."""
@@ skipping 119 matching lines @@
                 if t_contents == contents:
                     msg = "Two different environments were specified for target %s,\n\tbut they appear to have the same action: %s" % (t, action.genstring(tlist, slist, t.env))
                     SCons.Warnings.warn(SCons.Warnings.DuplicateEnvironmentWarning, msg)
                 else:
                     msg = "Two environments with different actions were specified for the same target: %s" % t
                     raise UserError, msg
             if builder.multi:
                 if t.builder != builder:
                     msg = "Two different builders (%s and %s) were specified for the same target: %s" % (t.builder.get_name(env), builder.get_name(env), t)
                     raise UserError, msg
-                if t.get_executor().targets != tlist:
-                    msg = "Two different target lists have a target in common: %s  (from %s and from %s)" % (t, map(str, t.get_executor().targets), map(str, tlist))
+                # TODO(batch):  list constructed each time!
+                if t.get_executor().get_all_targets() != tlist:
+                    msg = "Two different target lists have a target in common: %s  (from %s and from %s)" % (t, map(str, t.get_executor().get_all_targets()), map(str, tlist))
                     raise UserError, msg
             elif t.sources != slist:
                 msg = "Multiple ways to build the same target were specified for: %s  (from %s and from %s)" % (t, map(str, t.sources), map(str, slist))
                 raise UserError, msg
 
     if builder.single_source:
         if len(slist) > 1:
             raise UserError, "More than one source given for single-source builder: targets=%s sources=%s" % (map(str,tlist), map(str,slist))
 
 class EmitterProxy:
@@ skipping 124 matching lines @@
             except AttributeError:
                 return str(self.__class__)
 
     def __cmp__(self, other):
         return cmp(self.__dict__, other.__dict__)
 
     def splitext(self, path, env=None):
         if not env:
             env = self.env
         if env:
-            matchsuf = filter(lambda S,path=path: path[-len(S):] == S,
-                              self.src_suffixes(env))
-            if matchsuf:
-                suf = max(map(None, map(len, matchsuf), matchsuf))[1]
-                return [path[:-len(suf)], path[-len(suf):]]
-        return SCons.Util.splitext(path)
-
-    def get_single_executor(self, env, tlist, slist, executor_kw):
-        if not self.action:
-            raise UserError, "Builder %s must have an action to build %s."%(self.get_name(env or self.env), map(str,tlist))
-        return self.action.get_executor(env or self.env,
-                                        [],  # env already has overrides
-                                        tlist,
-                                        slist,
-                                        executor_kw)
-
-    def get_multi_executor(self, env, tlist, slist, executor_kw):
-        try:
-            executor = tlist[0].get_executor(create = 0)
-        except (AttributeError, IndexError):
-            return self.get_single_executor(env, tlist, slist, executor_kw)
+            suffixes = self.src_suffixes(env)
         else:
-            executor.add_sources(slist)
-            return executor
+            suffixes = []
+        return match_splitext(path, suffixes)
 
     def _adjustixes(self, files, pre, suf, ensure_suffix=False):
         if not files:
             return []
         result = []
         if not SCons.Util.is_List(files):
             files = [files]
 
         for f in files:
             if SCons.Util.is_String(f):
@@ skipping 81 matching lines @@
         overwarn.warn()
 
         tlist, slist = self._create_nodes(env, target, source)
 
         # Check for errors with the specified target/source lists.
         _node_errors(self, env, tlist, slist)
 
         # The targets are fine, so find or make the appropriate Executor to
         # build this particular list of targets from this particular list of
         # sources.
+
+        executor = None
+        key = None
+
         if self.multi:
-            get_executor = self.get_multi_executor
-        else:
-            get_executor = self.get_single_executor
-        executor = get_executor(env, tlist, slist, executor_kw)
+            try:
+                executor = tlist[0].get_executor(create = 0)
+            except (AttributeError, IndexError):
+                pass
+            else:
+                executor.add_sources(slist)
+
+        if executor is None:
+            if not self.action:
+                fmt = "Builder %s must have an action to build %s."
+                raise UserError, fmt % (self.get_name(env or self.env),
+                                        map(str,tlist))
+            key = self.action.batch_key(env or self.env, tlist, slist)
+            if key:
+                try:
+                    executor = SCons.Executor.GetBatchExecutor(key)
+                except KeyError:
+                    pass
+                else:
+                    executor.add_batch(tlist, slist)
+
+        if executor is None:
+            executor = SCons.Executor.Executor(self.action, env, [],
+                                               tlist, slist, executor_kw)
+            if key:
+                SCons.Executor.AddBatchExecutor(key, executor)
 
         # Now set up the relevant information in the target Nodes themselves.
         for t in tlist:
             t.cwd = env.fs.getcwd()
             t.builder_set(self)
             t.env_set(env)
             t.add_source(slist)
             t.set_executor(executor)
             t.set_explicit(self.is_explicit)
 
@@ skipping 251 matching lines @@
         if __debug__: logInstanceCreation(self, 'Builder.CompositeBuilder')
         SCons.Util.Proxy.__init__(self, builder)
 
         # cmdgen should always be an instance of DictCmdGenerator.
         self.cmdgen = cmdgen
         self.builder = builder
 
     def add_action(self, suffix, action):
         self.cmdgen.add_action(suffix, action)
         self.set_src_suffix(self.cmdgen.src_suffixes())