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

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

 """SCons.Util
 
 Various utility functions go here.
 
 """
 
 #
-# 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/Util.py 3842 2008/12/20 22:59:52 scons"
+__revision__ = "src/engine/SCons/Util.py 3897 2009/01/13 06:45:54 scons"
 
 import copy
 import os
 import os.path
 import re
 import string
 import sys
 import types
 
 from UserDict import UserDict
@@ skipping 59 matching lines @@
     Make the drive letter (if any) upper case.
     This is useful because Windows is inconsitent on the case
     of the drive letter, which can cause inconsistencies when
     calculating command signatures.
     """
     drive, rest = os.path.splitdrive(path)
     if drive:
         path = string.upper(drive) + rest
     return path
 
-class CallableComposite(UserList):
-    """A simple composite callable class that, when called, will invoke all
-    of its contained callables with the same arguments."""
-    def __call__(self, *args, **kwargs):
-        retvals = map(lambda x, args=args, kwargs=kwargs: apply(x,
-                                                                args,
-                                                                kwargs),
-                      self.data)
-        if self.data and (len(self.data) == len(filter(callable, retvals))):
-            return self.__class__(retvals)
-        return NodeList(retvals)
-
 class NodeList(UserList):
     """This class is almost exactly like a regular list of Nodes
     (actually it can hold any object), with one important difference.
     If you try to get an attribute from this list, it will return that
     attribute from every item in the list.  For example:
 
     >>> someList = NodeList([ '  foo  ', '  bar  ' ])
     >>> someList.strip()
     [ 'foo', 'bar' ]
     """
     def __nonzero__(self):
         return len(self.data) != 0
 
     def __str__(self):
         return string.join(map(str, self.data))
 
+    def __iter__(self):
+        return iter(self.data)
+
+    def __call__(self, *args, **kwargs):
+        result = map(lambda x, args=args, kwargs=kwargs: apply(x,
+                                                               args,
+                                                               kwargs),
+                     self.data)
+        return self.__class__(result)
+
     def __getattr__(self, name):
-        if not self.data:
-            # If there is nothing in the list, then we have no attributes to
-            # pass through, so raise AttributeError for everything.
-            raise AttributeError, "NodeList has no attribute: %s" % name
+        result = map(lambda x, n=name: getattr(x, n), self.data)
+        return self.__class__(result)
 
-        # Return a list of the attribute, gotten from every element
-        # in the list
-        attrList = map(lambda x, n=name: getattr(x, n), self.data)
-
-        # Special case.  If the attribute is callable, we do not want
-        # to return a list of callables.  Rather, we want to return a
-        # single callable that, when called, will invoke the function on
-        # all elements of this list.
-        if self.data and (len(self.data) == len(filter(callable, attrList))):
-            return CallableComposite(attrList)
-        return self.__class__(attrList)
 
 _get_env_var = re.compile(r'^\$([_a-zA-Z]\w*|{[_a-zA-Z]\w*})$')
 
 def get_environment_var(varstr):
     """Given a string, first determine if it looks like a reference
     to a single environment variable, like "$FOO" or "${FOO}".
     If so, return that variable with no decorations ("FOO").
     If not, return None."""
     mo=_get_env_var.match(to_String(varstr))
     if mo:
@@ skipping 672 matching lines @@
                     # network issues.
                     continue
                 if stat.S_IMODE(st[stat.ST_MODE]) & 0111:
                     try:
                         reject.index(f)
                     except ValueError:
                         return os.path.normpath(f)
                     continue
         return None
 
-def PrependPath(oldpath, newpath, sep = os.pathsep, delete_existing=1):
+def PrependPath(oldpath, newpath, sep = os.pathsep, 
+                delete_existing=1, canonicalize=None):
     """This prepends newpath elements to the given oldpath.  Will only
     add any particular path once (leaving the first one it encounters
     and ignoring the rest, to preserve path order), and will
     os.path.normpath and os.path.normcase all paths to help assure
     this.  This can also handle the case where the given old path
     variable is a list instead of a string, in which case a list will
     be returned instead of a string.
 
     Example:
       Old Path: "/foo/bar:/foo"
       New Path: "/biz/boom:/foo"
       Result:   "/biz/boom:/foo:/foo/bar"
 
     If delete_existing is 0, then adding a path that exists will
     not move it to the beginning; it will stay where it is in the
     list.
+
+    If canonicalize is not None, it is applied to each element of 
+    newpath before use.
     """
 
     orig = oldpath
     is_list = 1
     paths = orig
     if not is_List(orig) and not is_Tuple(orig):
         paths = string.split(paths, sep)
         is_list = 0
 
-    if is_List(newpath) or is_Tuple(newpath):
+    if is_String(newpath):
+        newpaths = string.split(newpath, sep)
+    elif not is_List(newpath) and not is_Tuple(newpath):
+        newpaths = [ newpath ]  # might be a Dir
+    else:
         newpaths = newpath
-    else:
-        newpaths = string.split(newpath, sep)
+
+    if canonicalize:
+        newpaths=map(canonicalize, newpaths)
 
     if not delete_existing:
         # First uniquify the old paths, making sure to 
         # preserve the first instance (in Unix/Linux,
         # the first one wins), and remembering them in normpaths.
         # Then insert the new paths at the head of the list
         # if they're not already in the normpaths list.
         result = []
         normpaths = []
         for path in paths:
@@ skipping 23 matching lines @@
             normpath = os.path.normpath(os.path.normcase(path))
             if path and not normpath in normpaths:
                 paths.append(path)
                 normpaths.append(normpath)
 
     if is_list:
         return paths
     else:
         return string.join(paths, sep)
 
-def AppendPath(oldpath, newpath, sep = os.pathsep, delete_existing=1):
+def AppendPath(oldpath, newpath, sep = os.pathsep, 
+               delete_existing=1, canonicalize=None):
     """This appends new path elements to the given old path.  Will
     only add any particular path once (leaving the last one it
     encounters and ignoring the rest, to preserve path order), and
     will os.path.normpath and os.path.normcase all paths to help
     assure this.  This can also handle the case where the given old
     path variable is a list instead of a string, in which case a list
     will be returned instead of a string.
 
     Example:
       Old Path: "/foo/bar:/foo"
       New Path: "/biz/boom:/foo"
       Result:   "/foo/bar:/biz/boom:/foo"
 
     If delete_existing is 0, then adding a path that exists
     will not move it to the end; it will stay where it is in the list.
+
+    If canonicalize is not None, it is applied to each element of 
+    newpath before use.
     """
 
     orig = oldpath
     is_list = 1
     paths = orig
     if not is_List(orig) and not is_Tuple(orig):
         paths = string.split(paths, sep)
         is_list = 0
 
-    if is_List(newpath) or is_Tuple(newpath):
+    if is_String(newpath):
+        newpaths = string.split(newpath, sep)
+    elif not is_List(newpath) and not is_Tuple(newpath):
+        newpaths = [ newpath ]  # might be a Dir
+    else:
         newpaths = newpath
-    else:
-        newpaths = string.split(newpath, sep)
+
+    if canonicalize:
+        newpaths=map(canonicalize, newpaths)
 
     if not delete_existing:
         # add old paths to result, then
         # add new paths if not already present
         # (I thought about using a dict for normpaths for speed,
         # but it's not clear hashing the strings would be faster
         # than linear searching these typically short lists.)
         result = []
         normpaths = []
         for path in paths:
@@ skipping 123 matching lines @@
         for (key, val) in dict.items():
             self.__setitem__(key, val)
 
     def values(self):
         return map(self.get, self._keys)
 
 class Selector(OrderedDict):
     """A callable ordered dictionary that maps file suffixes to
     dictionary values.  We preserve the order in which items are added
     so that get_suffix() calls always return the first suffix added."""
-    def __call__(self, env, source):
-        try:
-            ext = source[0].suffix
-        except IndexError:
-            ext = ""
+    def __call__(self, env, source, ext=None):
+        if ext is None:
+            try:
+                ext = source[0].suffix
+            except IndexError:
+                ext = ""
         try:
             return self[ext]
         except KeyError:
             # Try to perform Environment substitution on the keys of
             # the dictionary before giving up.
             s_dict = {}
             for (k,v) in self.items():
                 if not k is None:
                     s_k = env.subst(k)
                     if s_dict.has_key(s_k):
@@ skipping 435 matching lines @@
         return MD5signature(string.join(signatures, ', '))
 
 
 
 # From Dinu C. Gherman,
 # Python Cookbook, second edition, recipe 6.17, p. 277.
 # Also:
 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/68205
 # ASPN: Python Cookbook: Null Object Design Pattern
 
+# TODO(1.5):
+#class Null(object):
 class Null:
-    """ Null objects always and reliably "do nothging." """
-
+    """ Null objects always and reliably "do nothing." """
     def __new__(cls, *args, **kwargs):
         if not '_inst' in vars(cls):
             #cls._inst = type.__new__(cls, *args, **kwargs)
             cls._inst = apply(type.__new__, (cls,) + args, kwargs)
         return cls._inst
     def __init__(self, *args, **kwargs):
         pass
     def __call__(self, *args, **kwargs):
         return self
     def __repr__(self):
-        return "Null()"
+        return "Null(0x%08X)" % id(self)
     def __nonzero__(self):
         return False
-    def __getattr__(self, mname):
+    def __getattr__(self, name):
         return self
     def __setattr__(self, name, value):
         return self
     def __delattr__(self, name):
         return self
 
+class NullSeq(Null):
+    def __len__(self):
+        return 0
+    def __iter__(self):
+        return iter(())
+    def __getitem__(self, i):
+        return self
+    def __delitem__(self, i):
+        return self
+    def __setitem__(self, i, v):
+        return self
 
 
 del __revision__