Update to SCons 1.2.0.

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

 """SCons.Environment
 
 Base class for construction Environments.  These are
 the primary objects used to communicate dependency and
 construction information to the build engine.
 
 Keyword arguments supplied when the construction Environment
 is created are construction variables used to initialize the
 Environment
 """
@@ skipping 14 matching lines @@
 #
 # 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/Environment.py 3603 2008/10/10 05:46:45 scons"
+__revision__ = "src/engine/SCons/Environment.py 3842 2008/12/20 22:59:52 scons"
 
 
 import copy
 import os
 import sys
 import re
 import shlex
 import string
 from UserDict import UserDict
 
@@ skipping 52 matching lines @@
         return
     # Filter out null tools from the list.
     for tool in filter(None, tools):
         if SCons.Util.is_List(tool) or type(tool)==type(()):
             toolname = tool[0]
             toolargs = tool[1] # should be a dict of kw args
             tool = apply(env.Tool, [toolname], toolargs)
         else:
             env.Tool(tool)
 
-# These names are controlled by SCons; users should never set or override
-# them.  This warning can optionally be turned off, but scons will still
-# ignore the illegal variable names even if it's off.
-reserved_construction_var_names = \
-    ['TARGET', 'TARGETS', 'SOURCE', 'SOURCES']
+# These names are (or will be) controlled by SCons; users should never
+# set or override them.  This warning can optionally be turned off,
+# but scons will still ignore the illegal variable names even if it's off.
+reserved_construction_var_names = [
+    'SOURCE',
+    'SOURCES',
+    'TARGET',
+    'TARGETS',
+]
+
+future_reserved_construction_var_names = [
+    'CHANGED_SOURCES',
+    'CHANGED_TARGETS',
+    'UNCHANGED_SOURCES',
+    'UNCHANGED_TARGETS',
+]
 
 def copy_non_reserved_keywords(dict):
     result = semi_deepcopy(dict)
     for k in result.keys():
         if k in reserved_construction_var_names:
-            SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning,
-                                "Ignoring attempt to set reserved variable `%s'" % k)
+            msg = "Ignoring attempt to set reserved variable `$%s'"
+            SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning, msg % k)
             del result[k]
     return result
 
 def _set_reserved(env, key, value):
-    msg = "Ignoring attempt to set reserved variable `%s'" % key
-    SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning, msg)
+    msg = "Ignoring attempt to set reserved variable `$%s'"
+    SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning, msg % key)
+
+def _set_future_reserved(env, key, value):
+    env._dict[key] = value
+    msg = "`$%s' will be reserved in a future release and setting it will become ignored"
+    SCons.Warnings.warn(SCons.Warnings.FutureReservedVariableWarning, msg % key)
 
 def _set_BUILDERS(env, key, value):
     try:
         bd = env._dict[key]
         for k in bd.keys():
             del bd[k]
     except KeyError:
         bd = BuilderDict(kwbd, env)
         env._dict[key] = bd
     bd.update(value)
 
 def _del_SCANNERS(env, key):
     del env._dict[key]
     env.scanner_map_delete()
 
 def _set_SCANNERS(env, key, value):
     env._dict[key] = value
     env.scanner_map_delete()
 
+def _delete_duplicates(l, keep_last):
+    """Delete duplicates from a sequence, keeping the first or last."""
+    seen={}
+    result=[]
+    if keep_last:           # reverse in & out, then keep first
+        l.reverse()
+    for i in l:
+        try:
+            if not seen.has_key(i):
+                result.append(i)
+                seen[i]=1
+        except TypeError:
+            # probably unhashable.  Just keep it.
+            result.append(i)
+    if keep_last:
+        result.reverse()
+    return result
+
 
 
 # The following is partly based on code in a comment added by Peter
 # Shannon at the following page (there called the "transplant" class):
 #
 # ASPN : Python Cookbook : Dynamically added methods to a class
 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81732
 #
 # We had independently been using the idiom as BuilderWrapper, but
 # factoring out the common parts into this base class, and making
@@ skipping 57 matching lines @@
         if source is _null:
             source = target
             target = None
         if not target is None and not SCons.Util.is_List(target):
             target = [target]
         if not source is None and not SCons.Util.is_List(source):
             source = [source]
         return apply(MethodWrapper.__call__, (self, target, source) + args, kw)
 
     def __repr__(self):
-        fmt = '<BuilderWrapper %s instance at 0x%08X>'
-        return fmt % (repr(self.name), id(self))
+        return '<BuilderWrapper %s>' % repr(self.name)
 
     def __str__(self):
         return self.__repr__()
 
     def __getattr__(self, name):
         if name == 'env':
             return self.object
         elif name == 'builder':
             return self.method
         else:
@@ skipping 106 matching lines @@
 
     def _init_special(self):
         """Initial the dispatch tables for special handling of
         special construction variables."""
         self._special_del = {}
         self._special_del['SCANNERS'] = _del_SCANNERS
 
         self._special_set = {}
         for key in reserved_construction_var_names:
             self._special_set[key] = _set_reserved
+        for key in future_reserved_construction_var_names:
+            self._special_set[key] = _set_future_reserved
         self._special_set['BUILDERS'] = _set_BUILDERS
         self._special_set['SCANNERS'] = _set_SCANNERS
 
         # Freeze the keys of self._special_set in a list for use by
         # methods that need to check.  (Empirically, list scanning has
         # gotten better than dict.has_key() in Python 2.5.)
         self._special_set_keys = self._special_set.keys()
 
     def __cmp__(self, other):
         return cmp(self._dict, other._dict)
@@ skipping 33 matching lines @@
                     raise SCons.Errors.UserError, "Illegal construction variable `%s'" % key
             self._dict[key] = value
 
     def get(self, key, default=None):
         "Emulates the get() method of dictionaries."""
         return self._dict.get(key, default)
 
     def has_key(self, key):
         return self._dict.has_key(key)
 
+    def __contains__(self, key):
+        return self._dict.__contains__(key)
+
     def items(self):
         return self._dict.items()
 
     def arg2nodes(self, args, node_factory=_null, lookup_list=_null, **kw):
         if node_factory is _null:
             node_factory = self.fs.File
         if lookup_list is _null:
             lookup_list = self.lookup_list
 
         if not args:
@@ skipping 108 matching lines @@
             else:
                 p = s(p)
             r.append(p)
         return r
 
     subst_target_source = subst
 
     def backtick(self, command):
         import subprocess
         # common arguments
-        kw = { 'stdout' : subprocess.PIPE,
+        kw = { 'stdin' : 'devnull',
+               'stdout' : subprocess.PIPE,
                'stderr' : subprocess.PIPE,
                'universal_newlines' : True,
              }
         # if the command is a list, assume it's been quoted
         # othewise force a shell
         if not SCons.Util.is_List(command): kw['shell'] = True
         # run constructed command
         #TODO(1.5) p = SCons.Action._subproc(self, command, **kw)
         p = apply(SCons.Action._subproc, (self, command), kw)
         out,err = p.communicate()
@@ skipping 641 matching lines @@
         self._dict[envname][name] = nv
 
     def AppendUnique(self, delete_existing=0, **kw):
         """Append values to existing construction variables
         in an Environment, if they're not already there.
         If delete_existing is 1, removes existing values first, so
         values move to end.
         """
         kw = copy_non_reserved_keywords(kw)
         for key, val in kw.items():
+            if SCons.Util.is_List(val):
+                val = _delete_duplicates(val, delete_existing)
             if not self._dict.has_key(key) or self._dict[key] in ('', None):
                 self._dict[key] = val
             elif SCons.Util.is_Dict(self._dict[key]) and \
                  SCons.Util.is_Dict(val):
                 self._dict[key].update(val)
             elif SCons.Util.is_List(val):
                 dk = self._dict[key]
                 if not SCons.Util.is_List(dk):
                     dk = [dk]
                 if delete_existing:
@@ skipping 333 matching lines @@
         self._dict[envname][name] = nv
 
     def PrependUnique(self, delete_existing=0, **kw):
         """Prepend values to existing construction variables
         in an Environment, if they're not already there.
         If delete_existing is 1, removes existing values first, so
         values move to front.
         """
         kw = copy_non_reserved_keywords(kw)
         for key, val in kw.items():
+            if SCons.Util.is_List(val):
+                val = _delete_duplicates(val, not delete_existing)
             if not self._dict.has_key(key) or self._dict[key] in ('', None):
                 self._dict[key] = val
             elif SCons.Util.is_Dict(self._dict[key]) and \
                  SCons.Util.is_Dict(val):
                 self._dict[key].update(val)
             elif SCons.Util.is_List(val):
                 dk = self._dict[key]
                 if not SCons.Util.is_List(dk):
                     dk = [dk]
                 if delete_existing:
@@ skipping 606 matching lines @@
         try:
             return self.__dict__['overrides'][key]
         except KeyError:
             return self.__dict__['__subject'].get(key, default)
     def has_key(self, key):
         try:
             self.__dict__['overrides'][key]
             return 1
         except KeyError:
             return self.__dict__['__subject'].has_key(key)
+    def __contains__(self, key):
+        if self.__dict__['overrides'].__contains__(key):
+            return 1
+        return self.__dict__['__subject'].__contains__(key)
     def Dictionary(self):
         """Emulates the items() method of dictionaries."""
         d = self.__dict__['__subject'].Dictionary().copy()
         d.update(self.__dict__['overrides'])
         return d
     def items(self):
         """Emulates the items() method of dictionaries."""
         return self.Dictionary().items()
 
     # Overridden private construction environment methods.
@@ skipping 62 matching lines @@
             nkw['gvars'] = {}
             self.raw_to_mode(nkw)
             return apply(SCons.Subst.scons_subst_list, nargs, nkw)
         def subst_target_source(self, string, *args, **kwargs):
             nargs = (string, self,) + args
             nkw = kwargs.copy()
             nkw['gvars'] = {}
             self.raw_to_mode(nkw)
             return apply(SCons.Subst.scons_subst, nargs, nkw)
     return _NoSubstitutionProxy(subject)