Environment.py.svn-base
上传用户:market2
上传日期:2018-11-18
资源大小:18786k
文件大小:85k
源码类别:

外挂编程

开发平台:

Windows_Unix

  1. """SCons.Environment
  2. Base class for construction Environments.  These are
  3. the primary objects used to communicate dependency and
  4. construction information to the build engine.
  5. Keyword arguments supplied when the construction Environment
  6. is created are construction variables used to initialize the
  7. Environment
  8. """
  9. #
  10. # Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation
  11. #
  12. # Permission is hereby granted, free of charge, to any person obtaining
  13. # a copy of this software and associated documentation files (the
  14. # "Software"), to deal in the Software without restriction, including
  15. # without limitation the rights to use, copy, modify, merge, publish,
  16. # distribute, sublicense, and/or sell copies of the Software, and to
  17. # permit persons to whom the Software is furnished to do so, subject to
  18. # the following conditions:
  19. #
  20. # The above copyright notice and this permission notice shall be included
  21. # in all copies or substantial portions of the Software.
  22. #
  23. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  24. # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  25. # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26. # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27. # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28. # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29. # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30. #
  31. __revision__ = "src/engine/SCons/Environment.py 3057 2008/06/09 22:21:00 knight"
  32. import copy
  33. import os
  34. import os.path
  35. import re
  36. import shlex
  37. import string
  38. from UserDict import UserDict
  39. import SCons.Action
  40. import SCons.Builder
  41. from SCons.Debug import logInstanceCreation
  42. import SCons.Defaults
  43. import SCons.Errors
  44. import SCons.Memoize
  45. import SCons.Node
  46. import SCons.Node.Alias
  47. import SCons.Node.FS
  48. import SCons.Node.Python
  49. import SCons.Platform
  50. import SCons.SConsign
  51. import SCons.Subst
  52. import SCons.Tool
  53. import SCons.Util
  54. import SCons.Warnings
  55. class _Null:
  56.     pass
  57. _null = _Null
  58. _warn_copy_deprecated = True
  59. _warn_source_signatures_deprecated = True
  60. _warn_target_signatures_deprecated = True
  61. CleanTargets = {}
  62. CalculatorArgs = {}
  63. semi_deepcopy = SCons.Util.semi_deepcopy
  64. # Pull UserError into the global name space for the benefit of
  65. # Environment().SourceSignatures(), which has some import statements
  66. # which seem to mess up its ability to reference SCons directly.
  67. UserError = SCons.Errors.UserError
  68. def alias_builder(env, target, source):
  69.     pass
  70. AliasBuilder = SCons.Builder.Builder(action = alias_builder,
  71.                                      target_factory = SCons.Node.Alias.default_ans.Alias,
  72.                                      source_factory = SCons.Node.FS.Entry,
  73.                                      multi = 1,
  74.                                      is_explicit = None,
  75.                                      name='AliasBuilder')
  76. def apply_tools(env, tools, toolpath):
  77.     # Store the toolpath in the Environment.
  78.     if toolpath is not None:
  79.         env['toolpath'] = toolpath
  80.     if not tools:
  81.         return
  82.     # Filter out null tools from the list.
  83.     for tool in filter(None, tools):
  84.         if SCons.Util.is_List(tool) or type(tool)==type(()):
  85.             toolname = tool[0]
  86.             toolargs = tool[1] # should be a dict of kw args
  87.             tool = apply(env.Tool, [toolname], toolargs)
  88.         else:
  89.             env.Tool(tool)
  90. # These names are controlled by SCons; users should never set or override
  91. # them.  This warning can optionally be turned off, but scons will still
  92. # ignore the illegal variable names even if it's off.
  93. reserved_construction_var_names = 
  94.     ['TARGET', 'TARGETS', 'SOURCE', 'SOURCES']
  95. def copy_non_reserved_keywords(dict):
  96.     result = semi_deepcopy(dict)
  97.     for k in result.keys():
  98.         if k in reserved_construction_var_names:
  99.             SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning,
  100.                                 "Ignoring attempt to set reserved variable `%s'" % k)
  101.             del result[k]
  102.     return result
  103. def _set_reserved(env, key, value):
  104.     msg = "Ignoring attempt to set reserved variable `%s'" % key
  105.     SCons.Warnings.warn(SCons.Warnings.ReservedVariableWarning, msg)
  106. def _set_BUILDERS(env, key, value):
  107.     try:
  108.         bd = env._dict[key]
  109.         for k in bd.keys():
  110.             del bd[k]
  111.     except KeyError:
  112.         bd = BuilderDict(kwbd, env)
  113.         env._dict[key] = bd
  114.     bd.update(value)
  115. def _del_SCANNERS(env, key):
  116.     del env._dict[key]
  117.     env.scanner_map_delete()
  118. def _set_SCANNERS(env, key, value):
  119.     env._dict[key] = value
  120.     env.scanner_map_delete()
  121. # The following is partly based on code in a comment added by Peter
  122. # Shannon at the following page (there called the "transplant" class):
  123. #
  124. # ASPN : Python Cookbook : Dynamically added methods to a class
  125. # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81732
  126. #
  127. # We had independently been using the idiom as BuilderWrapper, but
  128. # factoring out the common parts into this base class, and making
  129. # BuilderWrapper a subclass that overrides __call__() to enforce specific
  130. # Builder calling conventions, simplified some of our higher-layer code.
  131. class MethodWrapper:
  132.     """
  133.     A generic Wrapper class that associates a method (which can
  134.     actually be any callable) with an object.  As part of creating this
  135.     MethodWrapper object an attribute with the specified (by default,
  136.     the name of the supplied method) is added to the underlying object.
  137.     When that new "method" is called, our __call__() method adds the
  138.     object as the first argument, simulating the Python behavior of
  139.     supplying "self" on method calls.
  140.     We hang on to the name by which the method was added to the underlying
  141.     base class so that we can provide a method to "clone" ourselves onto
  142.     a new underlying object being copied (without which we wouldn't need
  143.     to save that info).
  144.     """
  145.     def __init__(self, object, method, name=None):
  146.         if name is None:
  147.             name = method.__name__
  148.         self.object = object
  149.         self.method = method
  150.         self.name = name
  151.         setattr(self.object, name, self)
  152.     def __call__(self, *args, **kwargs):
  153.         nargs = (self.object,) + args
  154.         return apply(self.method, nargs, kwargs)
  155.     def clone(self, new_object):
  156.         """
  157.         Returns an object that re-binds the underlying "method" to
  158.         the specified new object.
  159.         """
  160.         return self.__class__(new_object, self.method, self.name)
  161. class BuilderWrapper(MethodWrapper):
  162.     """
  163.     A MethodWrapper subclass that that associates an environment with
  164.     a Builder.
  165.     This mainly exists to wrap the __call__() function so that all calls
  166.     to Builders can have their argument lists massaged in the same way
  167.     (treat a lone argument as the source, treat two arguments as target
  168.     then source, make sure both target and source are lists) without
  169.     having to have cut-and-paste code to do it.
  170.     As a bit of obsessive backwards compatibility, we also intercept
  171.     attempts to get or set the "env" or "builder" attributes, which were
  172.     the names we used before we put the common functionality into the
  173.     MethodWrapper base class.  We'll keep this around for a while in case
  174.     people shipped Tool modules that reached into the wrapper (like the
  175.     Tool/qt.py module does, or did).  There shouldn't be a lot attribute
  176.     fetching or setting on these, so a little extra work shouldn't hurt.
  177.     """
  178.     def __call__(self, target=None, source=_null, *args, **kw):
  179.         if source is _null:
  180.             source = target
  181.             target = None
  182.         if not target is None and not SCons.Util.is_List(target):
  183.             target = [target]
  184.         if not source is None and not SCons.Util.is_List(source):
  185.             source = [source]
  186.         return apply(MethodWrapper.__call__, (self, target, source) + args, kw)
  187.     def __repr__(self):
  188.         return '<BuilderWrapper %s>' % repr(self.name)
  189.     def __str__(self):
  190.         return self.__repr__()
  191.     def __getattr__(self, name):
  192.         if name == 'env':
  193.             return self.object
  194.         elif name == 'builder':
  195.             return self.method
  196.         else:
  197.             return self.__dict__[name]
  198.     def __setattr__(self, name, value):
  199.         if name == 'env':
  200.             self.object = value
  201.         elif name == 'builder':
  202.             self.method = value
  203.         else:
  204.             self.__dict__[name] = value
  205.     # This allows a Builder to be executed directly
  206.     # through the Environment to which it's attached.
  207.     # In practice, we shouldn't need this, because
  208.     # builders actually get executed through a Node.
  209.     # But we do have a unit test for this, and can't
  210.     # yet rule out that it would be useful in the
  211.     # future, so leave it for now.
  212.     #def execute(self, **kw):
  213.     #    kw['env'] = self.env
  214.     #    apply(self.builder.execute, (), kw)
  215. class BuilderDict(UserDict):
  216.     """This is a dictionary-like class used by an Environment to hold
  217.     the Builders.  We need to do this because every time someone changes
  218.     the Builders in the Environment's BUILDERS dictionary, we must
  219.     update the Environment's attributes."""
  220.     def __init__(self, dict, env):
  221.         # Set self.env before calling the superclass initialization,
  222.         # because it will end up calling our other methods, which will
  223.         # need to point the values in this dictionary to self.env.
  224.         self.env = env
  225.         UserDict.__init__(self, dict)
  226.     def __semi_deepcopy__(self):
  227.         return self.__class__(self.data, self.env)
  228.     def __setitem__(self, item, val):
  229.         try:
  230.             method = getattr(self.env, item).method
  231.         except AttributeError:
  232.             pass
  233.         else:
  234.             self.env.RemoveMethod(method)
  235.         UserDict.__setitem__(self, item, val)
  236.         BuilderWrapper(self.env, val, item)
  237.     def __delitem__(self, item):
  238.         UserDict.__delitem__(self, item)
  239.         delattr(self.env, item)
  240.     def update(self, dict):
  241.         for i, v in dict.items():
  242.             self.__setitem__(i, v)
  243. _is_valid_var = re.compile(r'[_a-zA-Z]w*$')
  244. def is_valid_construction_var(varstr):
  245.     """Return if the specified string is a legitimate construction
  246.     variable.
  247.     """
  248.     return _is_valid_var.match(varstr)
  249. class SubstitutionEnvironment:
  250.     """Base class for different flavors of construction environments.
  251.     This class contains a minimal set of methods that handle contruction
  252.     variable expansion and conversion of strings to Nodes, which may or
  253.     may not be actually useful as a stand-alone class.  Which methods
  254.     ended up in this class is pretty arbitrary right now.  They're
  255.     basically the ones which we've empirically determined are common to
  256.     the different construction environment subclasses, and most of the
  257.     others that use or touch the underlying dictionary of construction
  258.     variables.
  259.     Eventually, this class should contain all the methods that we
  260.     determine are necessary for a "minimal" interface to the build engine.
  261.     A full "native Python" SCons environment has gotten pretty heavyweight
  262.     with all of the methods and Tools and construction variables we've
  263.     jammed in there, so it would be nice to have a lighter weight
  264.     alternative for interfaces that don't need all of the bells and
  265.     whistles.  (At some point, we'll also probably rename this class
  266.     "Base," since that more reflects what we want this class to become,
  267.     but because we've released comments that tell people to subclass
  268.     Environment.Base to create their own flavors of construction
  269.     environment, we'll save that for a future refactoring when this
  270.     class actually becomes useful.)
  271.     """
  272.     if SCons.Memoize.use_memoizer:
  273.         __metaclass__ = SCons.Memoize.Memoized_Metaclass
  274.     def __init__(self, **kw):
  275.         """Initialization of an underlying SubstitutionEnvironment class.
  276.         """
  277.         if __debug__: logInstanceCreation(self, 'Environment.SubstitutionEnvironment')
  278.         self.fs = SCons.Node.FS.get_default_fs()
  279.         self.ans = SCons.Node.Alias.default_ans
  280.         self.lookup_list = SCons.Node.arg2nodes_lookups
  281.         self._dict = kw.copy()
  282.         self._init_special()
  283.         self.added_methods = []
  284.         #self._memo = {}
  285.     def _init_special(self):
  286.         """Initial the dispatch tables for special handling of
  287.         special construction variables."""
  288.         self._special_del = {}
  289.         self._special_del['SCANNERS'] = _del_SCANNERS
  290.         self._special_set = {}
  291.         for key in reserved_construction_var_names:
  292.             self._special_set[key] = _set_reserved
  293.         self._special_set['BUILDERS'] = _set_BUILDERS
  294.         self._special_set['SCANNERS'] = _set_SCANNERS
  295.         # Freeze the keys of self._special_set in a list for use by
  296.         # methods that need to check.  (Empirically, list scanning has
  297.         # gotten better than dict.has_key() in Python 2.5.)
  298.         self._special_set_keys = self._special_set.keys()
  299.     def __cmp__(self, other):
  300.         return cmp(self._dict, other._dict)
  301.     def __delitem__(self, key):
  302.         special = self._special_del.get(key)
  303.         if special:
  304.             special(self, key)
  305.         else:
  306.             del self._dict[key]
  307.     def __getitem__(self, key):
  308.         return self._dict[key]
  309.     def __setitem__(self, key, value):
  310.         # This is heavily used.  This implementation is the best we have
  311.         # according to the timings in bench/env.__setitem__.py.
  312.         #
  313.         # The "key in self._special_set_keys" test here seems to perform
  314.         # pretty well for the number of keys we have.  A hard-coded
  315.         # list works a little better in Python 2.5, but that has the
  316.         # disadvantage of maybe getting out of sync if we ever add more
  317.         # variable names.  Using self._special_set.has_key() works a
  318.         # little better in Python 2.4, but is worse then this test.
  319.         # So right now it seems like a good trade-off, but feel free to
  320.         # revisit this with bench/env.__setitem__.py as needed (and
  321.         # as newer versions of Python come out).
  322.         if key in self._special_set_keys:
  323.             self._special_set[key](self, key, value)
  324.         else:
  325.             # If we already have the entry, then it's obviously a valid
  326.             # key and we don't need to check.  If we do check, using a
  327.             # global, pre-compiled regular expression directly is more
  328.             # efficient than calling another function or a method.
  329.             if not self._dict.has_key(key) 
  330.                and not _is_valid_var.match(key):
  331.                     raise SCons.Errors.UserError, "Illegal construction variable `%s'" % key
  332.             self._dict[key] = value
  333.     def get(self, key, default=None):
  334.         "Emulates the get() method of dictionaries."""
  335.         return self._dict.get(key, default)
  336.     def has_key(self, key):
  337.         return self._dict.has_key(key)
  338.     def items(self):
  339.         return self._dict.items()
  340.     def arg2nodes(self, args, node_factory=_null, lookup_list=_null, **kw):
  341.         if node_factory is _null:
  342.             node_factory = self.fs.File
  343.         if lookup_list is _null:
  344.             lookup_list = self.lookup_list
  345.         if not args:
  346.             return []
  347.         args = SCons.Util.flatten(args)
  348.         nodes = []
  349.         for v in args:
  350.             if SCons.Util.is_String(v):
  351.                 n = None
  352.                 for l in lookup_list:
  353.                     n = l(v)
  354.                     if not n is None:
  355.                         break
  356.                 if not n is None:
  357.                     if SCons.Util.is_String(n):
  358.                         # n = self.subst(n, raw=1, **kw)
  359.                         kw['raw'] = 1
  360.                         n = apply(self.subst, (n,), kw)
  361.                         if node_factory:
  362.                             n = node_factory(n)
  363.                     if SCons.Util.is_List(n):
  364.                         nodes.extend(n)
  365.                     else:
  366.                         nodes.append(n)
  367.                 elif node_factory:
  368.                     # v = node_factory(self.subst(v, raw=1, **kw))
  369.                     kw['raw'] = 1
  370.                     v = node_factory(apply(self.subst, (v,), kw))
  371.                     if SCons.Util.is_List(v):
  372.                         nodes.extend(v)
  373.                     else:
  374.                         nodes.append(v)
  375.             else:
  376.                 nodes.append(v)
  377.         return nodes
  378.     def gvars(self):
  379.         return self._dict
  380.     def lvars(self):
  381.         return {}
  382.     def subst(self, string, raw=0, target=None, source=None, conv=None):
  383.         """Recursively interpolates construction variables from the
  384.         Environment into the specified string, returning the expanded
  385.         result.  Construction variables are specified by a $ prefix
  386.         in the string and begin with an initial underscore or
  387.         alphabetic character followed by any number of underscores
  388.         or alphanumeric characters.  The construction variable names
  389.         may be surrounded by curly braces to separate the name from
  390.         trailing characters.
  391.         """
  392.         gvars = self.gvars()
  393.         lvars = self.lvars()
  394.         lvars['__env__'] = self
  395.         return SCons.Subst.scons_subst(string, self, raw, target, source, gvars, lvars, conv)
  396.     def subst_kw(self, kw, raw=0, target=None, source=None):
  397.         nkw = {}
  398.         for k, v in kw.items():
  399.             k = self.subst(k, raw, target, source)
  400.             if SCons.Util.is_String(v):
  401.                 v = self.subst(v, raw, target, source)
  402.             nkw[k] = v
  403.         return nkw
  404.     def subst_list(self, string, raw=0, target=None, source=None, conv=None):
  405.         """Calls through to SCons.Subst.scons_subst_list().  See
  406.         the documentation for that function."""
  407.         gvars = self.gvars()
  408.         lvars = self.lvars()
  409.         lvars['__env__'] = self
  410.         return SCons.Subst.scons_subst_list(string, self, raw, target, source, gvars, lvars, conv)
  411.     def subst_path(self, path, target=None, source=None):
  412.         """Substitute a path list, turning EntryProxies into Nodes
  413.         and leaving Nodes (and other objects) as-is."""
  414.         if not SCons.Util.is_List(path):
  415.             path = [path]
  416.         def s(obj):
  417.             """This is the "string conversion" routine that we have our
  418.             substitutions use to return Nodes, not strings.  This relies
  419.             on the fact that an EntryProxy object has a get() method that
  420.             returns the underlying Node that it wraps, which is a bit of
  421.             architectural dependence that we might need to break or modify
  422.             in the future in response to additional requirements."""
  423.             try:
  424.                 get = obj.get
  425.             except AttributeError:
  426.                 obj = SCons.Util.to_String_for_subst(obj)
  427.             else:
  428.                 obj = get()
  429.             return obj
  430.         r = []
  431.         for p in path:
  432.             if SCons.Util.is_String(p):
  433.                 p = self.subst(p, target=target, source=source, conv=s)
  434.                 if SCons.Util.is_List(p):
  435.                     if len(p) == 1:
  436.                         p = p[0]
  437.                     else:
  438.                         # We have an object plus a string, or multiple
  439.                         # objects that we need to smush together.  No choice
  440.                         # but to make them into a string.
  441.                         p = string.join(map(SCons.Util.to_String_for_subst, p), '')
  442.             else:
  443.                 p = s(p)
  444.             r.append(p)
  445.         return r
  446.     subst_target_source = subst
  447.     def backtick(self, command):
  448.         import subprocess
  449.         if SCons.Util.is_List(command): 
  450.             p = subprocess.Popen(command,
  451.                                  stdout=subprocess.PIPE,
  452.                                  stderr=subprocess.PIPE,
  453.                                  universal_newlines=True)
  454.         else:
  455.             p = subprocess.Popen(command,
  456.                                  stdout=subprocess.PIPE,
  457.                                  stderr=subprocess.PIPE,
  458.                                  universal_newlines=True,
  459.                                  shell=True)
  460.         out = p.stdout.read()
  461.         p.stdout.close()
  462.         err = p.stderr.read()
  463.         p.stderr.close()
  464.         status = p.wait()
  465.         if err:
  466.             import sys
  467.             sys.stderr.write(err)
  468.         if status:
  469.             raise OSError("'%s' exited %d" % (command, status))
  470.         return out
  471.     def AddMethod(self, function, name=None):
  472.         """
  473.         Adds the specified function as a method of this construction
  474.         environment with the specified name.  If the name is omitted,
  475.         the default name is the name of the function itself.
  476.         """
  477.         method = MethodWrapper(self, function, name)
  478.         self.added_methods.append(method)
  479.     def RemoveMethod(self, function):
  480.         """
  481.         Removes the specified function's MethodWrapper from the
  482.         added_methods list, so we don't re-bind it when making a clone.
  483.         """
  484.         is_not_func = lambda dm, f=function: not dm.method is f
  485.         self.added_methods = filter(is_not_func, self.added_methods)
  486.     def Override(self, overrides):
  487.         """
  488.         Produce a modified environment whose variables are overriden by
  489.         the overrides dictionaries.  "overrides" is a dictionary that
  490.         will override the variables of this environment.
  491.         This function is much more efficient than Clone() or creating
  492.         a new Environment because it doesn't copy the construction
  493.         environment dictionary, it just wraps the underlying construction
  494.         environment, and doesn't even create a wrapper object if there
  495.         are no overrides.
  496.         """
  497.         if not overrides: return self
  498.         o = copy_non_reserved_keywords(overrides)
  499.         if not o: return self
  500.         overrides = {}
  501.         merges = None
  502.         for key, value in o.items():
  503.             if key == 'parse_flags':
  504.                 merges = value
  505.             else:
  506.                 overrides[key] = SCons.Subst.scons_subst_once(value, self, key)
  507.         env = OverrideEnvironment(self, overrides)
  508.         if merges: env.MergeFlags(merges)
  509.         return env
  510.     def ParseFlags(self, *flags):
  511.         """
  512.         Parse the set of flags and return a dict with the flags placed
  513.         in the appropriate entry.  The flags are treated as a typical
  514.         set of command-line flags for a GNU-like toolchain and used to
  515.         populate the entries in the dict immediately below.  If one of
  516.         the flag strings begins with a bang (exclamation mark), it is
  517.         assumed to be a command and the rest of the string is executed;
  518.         the result of that evaluation is then added to the dict.
  519.         """
  520.         dict = {
  521.             'ASFLAGS'       : SCons.Util.CLVar(''),
  522.             'CFLAGS'        : SCons.Util.CLVar(''),
  523.             'CCFLAGS'       : SCons.Util.CLVar(''),
  524.             'CPPDEFINES'    : [],
  525.             'CPPFLAGS'      : SCons.Util.CLVar(''),
  526.             'CPPPATH'       : [],
  527.             'FRAMEWORKPATH' : SCons.Util.CLVar(''),
  528.             'FRAMEWORKS'    : SCons.Util.CLVar(''),
  529.             'LIBPATH'       : [],
  530.             'LIBS'          : [],
  531.             'LINKFLAGS'     : SCons.Util.CLVar(''),
  532.             'RPATH'         : [],
  533.         }
  534.         # The use of the "me" parameter to provide our own name for
  535.         # recursion is an egregious hack to support Python 2.1 and before.
  536.         def do_parse(arg, me, self = self, dict = dict):
  537.             # if arg is a sequence, recurse with each element
  538.             if not arg:
  539.                 return
  540.             if not SCons.Util.is_String(arg):
  541.                 for t in arg: me(t, me)
  542.                 return
  543.             # if arg is a command, execute it
  544.             if arg[0] == '!':
  545.                 arg = self.backtick(arg[1:])
  546.             # utility function to deal with -D option
  547.             def append_define(name, dict = dict):
  548.                 t = string.split(name, '=')
  549.                 if len(t) == 1:
  550.                     dict['CPPDEFINES'].append(name)
  551.                 else:
  552.                     dict['CPPDEFINES'].append([t[0], string.join(t[1:], '=')])
  553.             # Loop through the flags and add them to the appropriate option.
  554.             # This tries to strike a balance between checking for all possible
  555.             # flags and keeping the logic to a finite size, so it doesn't
  556.             # check for some that don't occur often.  It particular, if the
  557.             # flag is not known to occur in a config script and there's a way
  558.             # of passing the flag to the right place (by wrapping it in a -W
  559.             # flag, for example) we don't check for it.  Note that most
  560.             # preprocessor options are not handled, since unhandled options
  561.             # are placed in CCFLAGS, so unless the preprocessor is invoked
  562.             # separately, these flags will still get to the preprocessor.
  563.             # Other options not currently handled:
  564.             #  -iqoutedir      (preprocessor search path)
  565.             #  -u symbol       (linker undefined symbol)
  566.             #  -s              (linker strip files)
  567.             #  -static*        (linker static binding)
  568.             #  -shared*        (linker dynamic binding)
  569.             #  -symbolic       (linker global binding)
  570.             #  -R dir          (deprecated linker rpath)
  571.             # IBM compilers may also accept -qframeworkdir=foo
  572.     
  573.             params = shlex.split(arg)
  574.             append_next_arg_to = None   # for multi-word args
  575.             for arg in params:
  576.                 if append_next_arg_to:
  577.                    if append_next_arg_to == 'CPPDEFINES':
  578.                        append_define(arg)
  579.                    elif append_next_arg_to == '-include':
  580.                        t = ('-include', self.fs.File(arg))
  581.                        dict['CCFLAGS'].append(t)
  582.                    elif append_next_arg_to == '-isysroot':
  583.                        t = ('-isysroot', arg)
  584.                        dict['CCFLAGS'].append(t)
  585.                        dict['LINKFLAGS'].append(t)
  586.                    elif append_next_arg_to == '-arch':
  587.                        t = ('-arch', arg)
  588.                        dict['CCFLAGS'].append(t)
  589.                        dict['LINKFLAGS'].append(t)
  590.                    else:
  591.                        dict[append_next_arg_to].append(arg)
  592.                    append_next_arg_to = None
  593.                 elif not arg[0] in ['-', '+']:
  594.                     dict['LIBS'].append(self.fs.File(arg))
  595.                 elif arg[:2] == '-L':
  596.                     if arg[2:]:
  597.                         dict['LIBPATH'].append(arg[2:])
  598.                     else:
  599.                         append_next_arg_to = 'LIBPATH'
  600.                 elif arg[:2] == '-l':
  601.                     if arg[2:]:
  602.                         dict['LIBS'].append(arg[2:])
  603.                     else:
  604.                         append_next_arg_to = 'LIBS'
  605.                 elif arg[:2] == '-I':
  606.                     if arg[2:]:
  607.                         dict['CPPPATH'].append(arg[2:])
  608.                     else:
  609.                         append_next_arg_to = 'CPPPATH'
  610.                 elif arg[:4] == '-Wa,':
  611.                     dict['ASFLAGS'].append(arg[4:])
  612.                     dict['CCFLAGS'].append(arg)
  613.                 elif arg[:4] == '-Wl,':
  614.                     if arg[:11] == '-Wl,-rpath=':
  615.                         dict['RPATH'].append(arg[11:])
  616.                     elif arg[:7] == '-Wl,-R,':
  617.                         dict['RPATH'].append(arg[7:])
  618.                     elif arg[:6] == '-Wl,-R':
  619.                         dict['RPATH'].append(arg[6:])
  620.                     else:
  621.                         dict['LINKFLAGS'].append(arg)
  622.                 elif arg[:4] == '-Wp,':
  623.                     dict['CPPFLAGS'].append(arg)
  624.                 elif arg[:2] == '-D':
  625.                     if arg[2:]:
  626.                         append_define(arg[2:])
  627.                     else:
  628.                         append_next_arg_to = 'CPPDEFINES'
  629.                 elif arg == '-framework':
  630.                     append_next_arg_to = 'FRAMEWORKS'
  631.                 elif arg[:14] == '-frameworkdir=':
  632.                     dict['FRAMEWORKPATH'].append(arg[14:])
  633.                 elif arg[:2] == '-F':
  634.                     if arg[2:]:
  635.                         dict['FRAMEWORKPATH'].append(arg[2:])
  636.                     else:
  637.                         append_next_arg_to = 'FRAMEWORKPATH'
  638.                 elif arg == '-mno-cygwin':
  639.                     dict['CCFLAGS'].append(arg)
  640.                     dict['LINKFLAGS'].append(arg)
  641.                 elif arg == '-mwindows':
  642.                     dict['LINKFLAGS'].append(arg)
  643.                 elif arg == '-pthread':
  644.                     dict['CCFLAGS'].append(arg)
  645.                     dict['LINKFLAGS'].append(arg)
  646.                 elif arg[:5] == '-std=':
  647.                     dict['CFLAGS'].append(arg) # C only
  648.                 elif arg[0] == '+':
  649.                     dict['CCFLAGS'].append(arg)
  650.                     dict['LINKFLAGS'].append(arg)
  651.                 elif arg in ['-include', '-isysroot', '-arch']:
  652.                     append_next_arg_to = arg
  653.                 else:
  654.                     dict['CCFLAGS'].append(arg)
  655.     
  656.         for arg in flags:
  657.             do_parse(arg, do_parse)
  658.         return dict
  659.     def MergeFlags(self, args, unique=1):
  660.         """
  661.         Merge the dict in args into the construction variables.  If args
  662.         is not a dict, it is converted into a dict using ParseFlags.
  663.         If unique is not set, the flags are appended rather than merged.
  664.         """
  665.         if not SCons.Util.is_Dict(args):
  666.             args = self.ParseFlags(args)
  667.         if not unique:
  668.             apply(self.Append, (), args)
  669.             return self
  670.         for key, value in args.items():
  671.             if not value:
  672.                 continue
  673.             try:
  674.                 orig = self[key]
  675.             except KeyError:
  676.                 orig = value
  677.             else:
  678.                 if not orig:
  679.                     orig = value
  680.                 elif value:
  681.                     # Add orig and value.  The logic here was lifted from
  682.                     # part of env.Append() (see there for a lot of comments
  683.                     # about the order in which things are tried) and is
  684.                     # used mainly to handle coercion of strings to CLVar to
  685.                     # "do the right thing" given (e.g.) an original CCFLAGS
  686.                     # string variable like '-pipe -Wall'.
  687.                     try:
  688.                         orig = orig + value
  689.                     except (KeyError, TypeError):
  690.                         try:
  691.                             add_to_orig = orig.append
  692.                         except AttributeError:
  693.                             value.insert(0, orig)
  694.                             orig = value
  695.                         else:
  696.                             add_to_orig(value)
  697.             t = []
  698.             if key[-4:] == 'PATH':
  699.                 ### keep left-most occurence
  700.                 for v in orig:
  701.                     if v not in t:
  702.                         t.append(v)
  703.             else:
  704.                 ### keep right-most occurence
  705.                 orig.reverse()
  706.                 for v in orig:
  707.                     if v not in t:
  708.                         t.insert(0, v)
  709.             self[key] = t
  710.         return self
  711. # Used by the FindSourceFiles() method, below.
  712. # Stuck here for support of pre-2.2 Python versions.
  713. def build_source(ss, result):
  714.     for s in ss:
  715.         if isinstance(s, SCons.Node.FS.Dir):
  716.             build_source(s.all_children(), result)
  717.         elif s.has_builder():
  718.             build_source(s.sources, result)
  719.         elif isinstance(s.disambiguate(), SCons.Node.FS.File):
  720.             result.append(s)
  721. def default_decide_source(dependency, target, prev_ni):
  722.     f = SCons.Defaults.DefaultEnvironment().decide_source
  723.     return f(dependency, target, prev_ni)
  724. def default_decide_target(dependency, target, prev_ni):
  725.     f = SCons.Defaults.DefaultEnvironment().decide_target
  726.     return f(dependency, target, prev_ni)
  727. def default_copy_from_cache(src, dst):
  728.     f = SCons.Defaults.DefaultEnvironment().copy_from_cache
  729.     return f(src, dst)
  730. class Base(SubstitutionEnvironment):
  731.     """Base class for "real" construction Environments.  These are the
  732.     primary objects used to communicate dependency and construction
  733.     information to the build engine.
  734.     Keyword arguments supplied when the construction Environment
  735.     is created are construction variables used to initialize the
  736.     Environment.
  737.     """
  738.     if SCons.Memoize.use_memoizer:
  739.         __metaclass__ = SCons.Memoize.Memoized_Metaclass
  740.     memoizer_counters = []
  741.     #######################################################################
  742.     # This is THE class for interacting with the SCons build engine,
  743.     # and it contains a lot of stuff, so we're going to try to keep this
  744.     # a little organized by grouping the methods.
  745.     #######################################################################
  746.     #######################################################################
  747.     # Methods that make an Environment act like a dictionary.  These have
  748.     # the expected standard names for Python mapping objects.  Note that
  749.     # we don't actually make an Environment a subclass of UserDict for
  750.     # performance reasons.  Note also that we only supply methods for
  751.     # dictionary functionality that we actually need and use.
  752.     #######################################################################
  753.     def __init__(self,
  754.                  platform=None,
  755.                  tools=None,
  756.                  toolpath=None,
  757.                  variables=None,
  758.                  parse_flags = None,
  759.                  **kw):
  760.         """
  761.         Initialization of a basic SCons construction environment,
  762.         including setting up special construction variables like BUILDER,
  763.         PLATFORM, etc., and searching for and applying available Tools.
  764.         Note that we do *not* call the underlying base class
  765.         (SubsitutionEnvironment) initialization, because we need to
  766.         initialize things in a very specific order that doesn't work
  767.         with the much simpler base class initialization.
  768.         """
  769.         if __debug__: logInstanceCreation(self, 'Environment.Base')
  770.         self._memo = {}
  771.         self.fs = SCons.Node.FS.get_default_fs()
  772.         self.ans = SCons.Node.Alias.default_ans
  773.         self.lookup_list = SCons.Node.arg2nodes_lookups
  774.         self._dict = semi_deepcopy(SCons.Defaults.ConstructionEnvironment)
  775.         self._init_special()
  776.         self.added_methods = []
  777.         # We don't use AddMethod, or define these as methods in this
  778.         # class, because we *don't* want these functions to be bound
  779.         # methods.  They need to operate independently so that the
  780.         # settings will work properly regardless of whether a given
  781.         # target ends up being built with a Base environment or an
  782.         # OverrideEnvironment or what have you.
  783.         self.decide_target = default_decide_target
  784.         self.decide_source = default_decide_source
  785.         self.copy_from_cache = default_copy_from_cache
  786.         self._dict['BUILDERS'] = BuilderDict(self._dict['BUILDERS'], self)
  787.         if platform is None:
  788.             platform = self._dict.get('PLATFORM', None)
  789.             if platform is None:
  790.                 platform = SCons.Platform.Platform()
  791.         if SCons.Util.is_String(platform):
  792.             platform = SCons.Platform.Platform(platform)
  793.         self._dict['PLATFORM'] = str(platform)
  794.         platform(self)
  795.         # Apply the passed-in and customizable variables to the
  796.         # environment before calling the tools, because they may use
  797.         # some of them during initialization.
  798.         if kw.has_key('options'):
  799.             # Backwards compatibility:  they may stll be using the
  800.             # old "options" keyword.
  801.             variables = kw['options']
  802.             del kw['options']
  803.         apply(self.Replace, (), kw)
  804.         keys = kw.keys()
  805.         if variables:
  806.             keys = keys + variables.keys()
  807.             variables.Update(self)
  808.         save = {}
  809.         for k in keys:
  810.             try:
  811.                 save[k] = self._dict[k]
  812.             except KeyError:
  813.                 # No value may have been set if they tried to pass in a
  814.                 # reserved variable name like TARGETS.
  815.                 pass
  816.         SCons.Tool.Initializers(self)
  817.         if tools is None:
  818.             tools = self._dict.get('TOOLS', None)
  819.             if tools is None:
  820.                 tools = ['default']
  821.         apply_tools(self, tools, toolpath)
  822.         # Now restore the passed-in and customized variables
  823.         # to the environment, since the values the user set explicitly
  824.         # should override any values set by the tools.
  825.         for key, val in save.items():
  826.             self._dict[key] = val
  827.         # Finally, apply any flags to be merged in
  828.         if parse_flags: self.MergeFlags(parse_flags)
  829.     #######################################################################
  830.     # Utility methods that are primarily for internal use by SCons.
  831.     # These begin with lower-case letters.
  832.     #######################################################################
  833.     def get_builder(self, name):
  834.         """Fetch the builder with the specified name from the environment.
  835.         """
  836.         try:
  837.             return self._dict['BUILDERS'][name]
  838.         except KeyError:
  839.             return None
  840.     def get_CacheDir(self):
  841.         try:
  842.             path = self._CacheDir_path
  843.         except AttributeError:
  844.             path = SCons.Defaults.DefaultEnvironment()._CacheDir_path
  845.         try:
  846.             if path == self._last_CacheDir_path:
  847.                 return self._last_CacheDir
  848.         except AttributeError:
  849.             pass
  850.         cd = SCons.CacheDir.CacheDir(path)
  851.         self._last_CacheDir_path = path
  852.         self._last_CacheDir = cd
  853.         return cd
  854.     def get_factory(self, factory, default='File'):
  855.         """Return a factory function for creating Nodes for this
  856.         construction environment.
  857.         """
  858.         name = default
  859.         try:
  860.             is_node = issubclass(factory, SCons.Node.Node)
  861.         except TypeError:
  862.             # The specified factory isn't a Node itself--it's
  863.             # most likely None, or possibly a callable.
  864.             pass
  865.         else:
  866.             if is_node:
  867.                 # The specified factory is a Node (sub)class.  Try to
  868.                 # return the FS method that corresponds to the Node's
  869.                 # name--that is, we return self.fs.Dir if they want a Dir,
  870.                 # self.fs.File for a File, etc.
  871.                 try: name = factory.__name__
  872.                 except AttributeError: pass
  873.                 else: factory = None
  874.         if not factory:
  875.             # They passed us None, or we picked up a name from a specified
  876.             # class, so return the FS method.  (Note that we *don't*
  877.             # use our own self.{Dir,File} methods because that would
  878.             # cause env.subst() to be called twice on the file name,
  879.             # interfering with files that have $$ in them.)
  880.             factory = getattr(self.fs, name)
  881.         return factory
  882.     memoizer_counters.append(SCons.Memoize.CountValue('_gsm'))
  883.     def _gsm(self):
  884.         try:
  885.             return self._memo['_gsm']
  886.         except KeyError:
  887.             pass
  888.         result = {}
  889.         try:
  890.             scanners = self._dict['SCANNERS']
  891.         except KeyError:
  892.             pass
  893.         else:
  894.             # Reverse the scanner list so that, if multiple scanners
  895.             # claim they can scan the same suffix, earlier scanners
  896.             # in the list will overwrite later scanners, so that
  897.             # the result looks like a "first match" to the user.
  898.             if not SCons.Util.is_List(scanners):
  899.                 scanners = [scanners]
  900.             else:
  901.                 scanners = scanners[:] # copy so reverse() doesn't mod original
  902.             scanners.reverse()
  903.             for scanner in scanners:
  904.                 for k in scanner.get_skeys(self):
  905.                     result[k] = scanner
  906.         self._memo['_gsm'] = result
  907.         return result
  908.     def get_scanner(self, skey):
  909.         """Find the appropriate scanner given a key (usually a file suffix).
  910.         """
  911.         return self._gsm().get(skey)
  912.     def scanner_map_delete(self, kw=None):
  913.         """Delete the cached scanner map (if we need to).
  914.         """
  915.         try:
  916.             del self._memo['_gsm']
  917.         except KeyError:
  918.             pass
  919.     def _update(self, dict):
  920.         """Update an environment's values directly, bypassing the normal
  921.         checks that occur when users try to set items.
  922.         """
  923.         self._dict.update(dict)
  924.     def get_src_sig_type(self):
  925.         try:
  926.             return self.src_sig_type
  927.         except AttributeError:
  928.             t = SCons.Defaults.DefaultEnvironment().src_sig_type
  929.             self.src_sig_type = t
  930.             return t
  931.     def get_tgt_sig_type(self):
  932.         try:
  933.             return self.tgt_sig_type
  934.         except AttributeError:
  935.             t = SCons.Defaults.DefaultEnvironment().tgt_sig_type
  936.             self.tgt_sig_type = t
  937.             return t
  938.     #######################################################################
  939.     # Public methods for manipulating an Environment.  These begin with
  940.     # upper-case letters.  The essential characteristic of methods in
  941.     # this section is that they do *not* have corresponding same-named
  942.     # global functions.  For example, a stand-alone Append() function
  943.     # makes no sense, because Append() is all about appending values to
  944.     # an Environment's construction variables.
  945.     #######################################################################
  946.     def Append(self, **kw):
  947.         """Append values to existing construction variables
  948.         in an Environment.
  949.         """
  950.         kw = copy_non_reserved_keywords(kw)
  951.         for key, val in kw.items():
  952.             # It would be easier on the eyes to write this using
  953.             # "continue" statements whenever we finish processing an item,
  954.             # but Python 1.5.2 apparently doesn't let you use "continue"
  955.             # within try:-except: blocks, so we have to nest our code.
  956.             try:
  957.                 orig = self._dict[key]
  958.             except KeyError:
  959.                 # No existing variable in the environment, so just set
  960.                 # it to the new value.
  961.                 self._dict[key] = val
  962.             else:
  963.                 try:
  964.                     # Check if the original looks like a dictionary.
  965.                     # If it is, we can't just try adding the value because
  966.                     # dictionaries don't have __add__() methods, and
  967.                     # things like UserList will incorrectly coerce the
  968.                     # original dict to a list (which we don't want).
  969.                     update_dict = orig.update
  970.                 except AttributeError:
  971.                     try:
  972.                         # Most straightforward:  just try to add them
  973.                         # together.  This will work in most cases, when the
  974.                         # original and new values are of compatible types.
  975.                         self._dict[key] = orig + val
  976.                     except (KeyError, TypeError):
  977.                         try:
  978.                             # Check if the original is a list.
  979.                             add_to_orig = orig.append
  980.                         except AttributeError:
  981.                             # The original isn't a list, but the new
  982.                             # value is (by process of elimination),
  983.                             # so insert the original in the new value
  984.                             # (if there's one to insert) and replace
  985.                             # the variable with it.
  986.                             if orig:
  987.                                 val.insert(0, orig)
  988.                             self._dict[key] = val
  989.                         else:
  990.                             # The original is a list, so append the new
  991.                             # value to it (if there's a value to append).
  992.                             if val:
  993.                                 add_to_orig(val)
  994.                 else:
  995.                     # The original looks like a dictionary, so update it
  996.                     # based on what we think the value looks like.
  997.                     if SCons.Util.is_List(val):
  998.                         for v in val:
  999.                             orig[v] = None
  1000.                     else:
  1001.                         try:
  1002.                             update_dict(val)
  1003.                         except (AttributeError, TypeError, ValueError):
  1004.                             if SCons.Util.is_Dict(val):
  1005.                                 for k, v in val.items():
  1006.                                     orig[k] = v
  1007.                             else:
  1008.                                 orig[val] = None
  1009.         self.scanner_map_delete(kw)
  1010.     def AppendENVPath(self, name, newpath, envname = 'ENV', sep = os.pathsep):
  1011.         """Append path elements to the path 'name' in the 'ENV'
  1012.         dictionary for this environment.  Will only add any particular
  1013.         path once, and will normpath and normcase all paths to help
  1014.         assure this.  This can also handle the case where the env
  1015.         variable is a list instead of a string.
  1016.         """
  1017.         orig = ''
  1018.         if self._dict.has_key(envname) and self._dict[envname].has_key(name):
  1019.             orig = self._dict[envname][name]
  1020.         nv = SCons.Util.AppendPath(orig, newpath, sep)
  1021.         if not self._dict.has_key(envname):
  1022.             self._dict[envname] = {}
  1023.         self._dict[envname][name] = nv
  1024.     def AppendUnique(self, **kw):
  1025.         """Append values to existing construction variables
  1026.         in an Environment, if they're not already there.
  1027.         """
  1028.         kw = copy_non_reserved_keywords(kw)
  1029.         for key, val in kw.items():
  1030.             if not self._dict.has_key(key) or self._dict[key] in ('', None):
  1031.                 self._dict[key] = val
  1032.             elif SCons.Util.is_Dict(self._dict[key]) and 
  1033.                  SCons.Util.is_Dict(val):
  1034.                 self._dict[key].update(val)
  1035.             elif SCons.Util.is_List(val):
  1036.                 dk = self._dict[key]
  1037.                 if not SCons.Util.is_List(dk):
  1038.                     dk = [dk]
  1039.                 val = filter(lambda x, dk=dk: x not in dk, val)
  1040.                 self._dict[key] = dk + val
  1041.             else:
  1042.                 dk = self._dict[key]
  1043.                 if SCons.Util.is_List(dk):
  1044.                     # By elimination, val is not a list.  Since dk is a
  1045.                     # list, wrap val in a list first.
  1046.                     if not val in dk:
  1047.                         self._dict[key] = dk + [val]
  1048.                 else:
  1049.                     self._dict[key] = self._dict[key] + val
  1050.         self.scanner_map_delete(kw)
  1051.     def Clone(self, tools=[], toolpath=None, parse_flags = None, **kw):
  1052.         """Return a copy of a construction Environment.  The
  1053.         copy is like a Python "deep copy"--that is, independent
  1054.         copies are made recursively of each objects--except that
  1055.         a reference is copied when an object is not deep-copyable
  1056.         (like a function).  There are no references to any mutable
  1057.         objects in the original Environment.
  1058.         """
  1059.         clone = copy.copy(self)
  1060.         clone._dict = semi_deepcopy(self._dict)
  1061.         try:
  1062.             cbd = clone._dict['BUILDERS']
  1063.         except KeyError:
  1064.             pass
  1065.         else:
  1066.             clone._dict['BUILDERS'] = BuilderDict(cbd, clone)
  1067.         # Check the methods added via AddMethod() and re-bind them to
  1068.         # the cloned environment.  Only do this if the attribute hasn't
  1069.         # been overwritten by the user explicitly and still points to
  1070.         # the added method.
  1071.         clone.added_methods = []
  1072.         for mw in self.added_methods:
  1073.             if mw == getattr(self, mw.name):
  1074.                 clone.added_methods.append(mw.clone(clone))
  1075.         clone._memo = {}
  1076.         # Apply passed-in variables before the tools
  1077.         # so the tools can use the new variables
  1078.         kw = copy_non_reserved_keywords(kw)
  1079.         new = {}
  1080.         for key, value in kw.items():
  1081.             new[key] = SCons.Subst.scons_subst_once(value, self, key)
  1082.         apply(clone.Replace, (), new)
  1083.         apply_tools(clone, tools, toolpath)
  1084.         # apply them again in case the tools overwrote them
  1085.         apply(clone.Replace, (), new)        
  1086.         # Finally, apply any flags to be merged in
  1087.         if parse_flags: clone.MergeFlags(parse_flags)
  1088.         if __debug__: logInstanceCreation(self, 'Environment.EnvironmentClone')
  1089.         return clone
  1090.     def Copy(self, *args, **kw):
  1091.         global _warn_copy_deprecated
  1092.         if _warn_copy_deprecated:
  1093.             msg = "The env.Copy() method is deprecated; use the env.Clone() method instead."
  1094.             SCons.Warnings.warn(SCons.Warnings.DeprecatedCopyWarning, msg)
  1095.             _warn_copy_deprecated = False
  1096.         return apply(self.Clone, args, kw)
  1097.     def _changed_build(self, dependency, target, prev_ni):
  1098.         if dependency.changed_state(target, prev_ni):
  1099.             return 1
  1100.         return self.decide_source(dependency, target, prev_ni)
  1101.     def _changed_content(self, dependency, target, prev_ni):
  1102.         return dependency.changed_content(target, prev_ni)
  1103.     def _changed_source(self, dependency, target, prev_ni):
  1104.         target_env = dependency.get_build_env()
  1105.         type = target_env.get_tgt_sig_type()
  1106.         if type == 'source':
  1107.             return target_env.decide_source(dependency, target, prev_ni)
  1108.         else:
  1109.             return target_env.decide_target(dependency, target, prev_ni)
  1110.     def _changed_timestamp_then_content(self, dependency, target, prev_ni):
  1111.         return dependency.changed_timestamp_then_content(target, prev_ni)
  1112.     def _changed_timestamp_newer(self, dependency, target, prev_ni):
  1113.         return dependency.changed_timestamp_newer(target, prev_ni)
  1114.     def _changed_timestamp_match(self, dependency, target, prev_ni):
  1115.         return dependency.changed_timestamp_match(target, prev_ni)
  1116.     def _copy_from_cache(self, src, dst):
  1117.         return self.fs.copy(src, dst)
  1118.     def _copy2_from_cache(self, src, dst):
  1119.         return self.fs.copy2(src, dst)
  1120.     def Decider(self, function):
  1121.         copy_function = self._copy2_from_cache
  1122.         if function in ('MD5', 'content'):
  1123.             if not SCons.Util.md5:
  1124.                 raise UserError, "MD5 signatures are not available in this version of Python."
  1125.             function = self._changed_content
  1126.         elif function == 'MD5-timestamp':
  1127.             function = self._changed_timestamp_then_content
  1128.         elif function in ('timestamp-newer', 'make'):
  1129.             function = self._changed_timestamp_newer
  1130.             copy_function = self._copy_from_cache
  1131.         elif function == 'timestamp-match':
  1132.             function = self._changed_timestamp_match
  1133.         elif not callable(function):
  1134.             raise UserError, "Unknown Decider value %s" % repr(function)
  1135.         # We don't use AddMethod because we don't want to turn the
  1136.         # function, which only expects three arguments, into a bound
  1137.         # method, which would add self as an initial, fourth argument.
  1138.         self.decide_target = function
  1139.         self.decide_source = function
  1140.         self.copy_from_cache = copy_function
  1141.     def Detect(self, progs):
  1142.         """Return the first available program in progs.
  1143.         """
  1144.         if not SCons.Util.is_List(progs):
  1145.             progs = [ progs ]
  1146.         for prog in progs:
  1147.             path = self.WhereIs(prog)
  1148.             if path: return prog
  1149.         return None
  1150.     def Dictionary(self, *args):
  1151.         if not args:
  1152.             return self._dict
  1153.         dlist = map(lambda x, s=self: s._dict[x], args)
  1154.         if len(dlist) == 1:
  1155.             dlist = dlist[0]
  1156.         return dlist
  1157.     def Dump(self, key = None):
  1158.         """
  1159.         Using the standard Python pretty printer, dump the contents of the
  1160.         scons build environment to stdout.
  1161.         If the key passed in is anything other than None, then that will
  1162.         be used as an index into the build environment dictionary and
  1163.         whatever is found there will be fed into the pretty printer. Note
  1164.         that this key is case sensitive.
  1165.         """
  1166.         import pprint
  1167.         pp = pprint.PrettyPrinter(indent=2)
  1168.         if key:
  1169.             dict = self.Dictionary(key)
  1170.         else:
  1171.             dict = self.Dictionary()
  1172.         return pp.pformat(dict)
  1173.     def FindIxes(self, paths, prefix, suffix):
  1174.         """
  1175.         Search a list of paths for something that matches the prefix and suffix.
  1176.         paths - the list of paths or nodes.
  1177.         prefix - construction variable for the prefix.
  1178.         suffix - construction variable for the suffix.
  1179.         """
  1180.         suffix = self.subst('$'+suffix)
  1181.         prefix = self.subst('$'+prefix)
  1182.         for path in paths:
  1183.             dir,name = os.path.split(str(path))
  1184.             if name[:len(prefix)] == prefix and name[-len(suffix):] == suffix:
  1185.                 return path
  1186.     def ParseConfig(self, command, function=None, unique=1):
  1187.         """
  1188.         Use the specified function to parse the output of the command
  1189.         in order to modify the current environment.  The 'command' can
  1190.         be a string or a list of strings representing a command and
  1191.         its arguments.  'Function' is an optional argument that takes
  1192.         the environment, the output of the command, and the unique flag.
  1193.         If no function is specified, MergeFlags, which treats the output
  1194.         as the result of a typical 'X-config' command (i.e. gtk-config),
  1195.         will merge the output into the appropriate variables.
  1196.         """
  1197.         if function is None:
  1198.             def parse_conf(env, cmd, unique=unique):
  1199.                 return env.MergeFlags(cmd, unique)
  1200.             function = parse_conf
  1201.         if SCons.Util.is_List(command):
  1202.             command = string.join(command)
  1203.         command = self.subst(command)
  1204.         return function(self, self.backtick(command))
  1205.     def ParseDepends(self, filename, must_exist=None, only_one=0):
  1206.         """
  1207.         Parse a mkdep-style file for explicit dependencies.  This is
  1208.         completely abusable, and should be unnecessary in the "normal"
  1209.         case of proper SCons configuration, but it may help make
  1210.         the transition from a Make hierarchy easier for some people
  1211.         to swallow.  It can also be genuinely useful when using a tool
  1212.         that can write a .d file, but for which writing a scanner would
  1213.         be too complicated.
  1214.         """
  1215.         filename = self.subst(filename)
  1216.         try:
  1217.             fp = open(filename, 'r')
  1218.         except IOError:
  1219.             if must_exist:
  1220.                 raise
  1221.             return
  1222.         lines = SCons.Util.LogicalLines(fp).readlines()
  1223.         lines = filter(lambda l: l[0] != '#', lines)
  1224.         tdlist = []
  1225.         for line in lines:
  1226.             try:
  1227.                 target, depends = string.split(line, ':', 1)
  1228.             except (AttributeError, TypeError, ValueError):
  1229.                 # Python 1.5.2 throws TypeError if line isn't a string,
  1230.                 # Python 2.x throws AttributeError because it tries
  1231.                 # to call line.split().  Either can throw ValueError
  1232.                 # if the line doesn't split into two or more elements.
  1233.                 pass
  1234.             else:
  1235.                 tdlist.append((string.split(target), string.split(depends)))
  1236.         if only_one:
  1237.             targets = reduce(lambda x, y: x+y, map(lambda p: p[0], tdlist))
  1238.             if len(targets) > 1:
  1239.                 raise SCons.Errors.UserError, "More than one dependency target found in `%s':  %s" % (filename, targets)
  1240.         for target, depends in tdlist:
  1241.             self.Depends(target, depends)
  1242.     def Platform(self, platform):
  1243.         platform = self.subst(platform)
  1244.         return SCons.Platform.Platform(platform)(self)
  1245.     def Prepend(self, **kw):
  1246.         """Prepend values to existing construction variables
  1247.         in an Environment.
  1248.         """
  1249.         kw = copy_non_reserved_keywords(kw)
  1250.         for key, val in kw.items():
  1251.             # It would be easier on the eyes to write this using
  1252.             # "continue" statements whenever we finish processing an item,
  1253.             # but Python 1.5.2 apparently doesn't let you use "continue"
  1254.             # within try:-except: blocks, so we have to nest our code.
  1255.             try:
  1256.                 orig = self._dict[key]
  1257.             except KeyError:
  1258.                 # No existing variable in the environment, so just set
  1259.                 # it to the new value.
  1260.                 self._dict[key] = val
  1261.             else:
  1262.                 try:
  1263.                     # Check if the original looks like a dictionary.
  1264.                     # If it is, we can't just try adding the value because
  1265.                     # dictionaries don't have __add__() methods, and
  1266.                     # things like UserList will incorrectly coerce the
  1267.                     # original dict to a list (which we don't want).
  1268.                     update_dict = orig.update
  1269.                 except AttributeError:
  1270.                     try:
  1271.                         # Most straightforward:  just try to add them
  1272.                         # together.  This will work in most cases, when the
  1273.                         # original and new values are of compatible types.
  1274.                         self._dict[key] = val + orig
  1275.                     except (KeyError, TypeError):
  1276.                         try:
  1277.                             # Check if the added value is a list.
  1278.                             add_to_val = val.append
  1279.                         except AttributeError:
  1280.                             # The added value isn't a list, but the
  1281.                             # original is (by process of elimination),
  1282.                             # so insert the the new value in the original
  1283.                             # (if there's one to insert).
  1284.                             if val:
  1285.                                 orig.insert(0, val)
  1286.                         else:
  1287.                             # The added value is a list, so append
  1288.                             # the original to it (if there's a value
  1289.                             # to append).
  1290.                             if orig:
  1291.                                 add_to_val(orig)
  1292.                             self._dict[key] = val
  1293.                 else:
  1294.                     # The original looks like a dictionary, so update it
  1295.                     # based on what we think the value looks like.
  1296.                     if SCons.Util.is_List(val):
  1297.                         for v in val:
  1298.                             orig[v] = None
  1299.                     else:
  1300.                         try:
  1301.                             update_dict(val)
  1302.                         except (AttributeError, TypeError, ValueError):
  1303.                             if SCons.Util.is_Dict(val):
  1304.                                 for k, v in val.items():
  1305.                                     orig[k] = v
  1306.                             else:
  1307.                                 orig[val] = None
  1308.         self.scanner_map_delete(kw)
  1309.     def PrependENVPath(self, name, newpath, envname = 'ENV', sep = os.pathsep):
  1310.         """Prepend path elements to the path 'name' in the 'ENV'
  1311.         dictionary for this environment.  Will only add any particular
  1312.         path once, and will normpath and normcase all paths to help
  1313.         assure this.  This can also handle the case where the env
  1314.         variable is a list instead of a string.
  1315.         """
  1316.         orig = ''
  1317.         if self._dict.has_key(envname) and self._dict[envname].has_key(name):
  1318.             orig = self._dict[envname][name]
  1319.         nv = SCons.Util.PrependPath(orig, newpath, sep)
  1320.         if not self._dict.has_key(envname):
  1321.             self._dict[envname] = {}
  1322.         self._dict[envname][name] = nv
  1323.     def PrependUnique(self, **kw):
  1324.         """Append values to existing construction variables
  1325.         in an Environment, if they're not already there.
  1326.         """
  1327.         kw = copy_non_reserved_keywords(kw)
  1328.         for key, val in kw.items():
  1329.             if not self._dict.has_key(key) or self._dict[key] in ('', None):
  1330.                 self._dict[key] = val
  1331.             elif SCons.Util.is_Dict(self._dict[key]) and 
  1332.                  SCons.Util.is_Dict(val):
  1333.                 self._dict[key].update(val)
  1334.             elif SCons.Util.is_List(val):
  1335.                 dk = self._dict[key]
  1336.                 if not SCons.Util.is_List(dk):
  1337.                     dk = [dk]
  1338.                 val = filter(lambda x, dk=dk: x not in dk, val)
  1339.                 self._dict[key] = val + dk
  1340.             else:
  1341.                 dk = self._dict[key]
  1342.                 if SCons.Util.is_List(dk):
  1343.                     # By elimination, val is not a list.  Since dk is a
  1344.                     # list, wrap val in a list first.
  1345.                     if not val in dk:
  1346.                         self._dict[key] = [val] + dk
  1347.                 else:
  1348.                     self._dict[key] = val + dk
  1349.         self.scanner_map_delete(kw)
  1350.     def Replace(self, **kw):
  1351.         """Replace existing construction variables in an Environment
  1352.         with new construction variables and/or values.
  1353.         """
  1354.         try:
  1355.             kwbd = kw['BUILDERS']
  1356.         except KeyError:
  1357.             pass
  1358.         else:
  1359.             kwbd = semi_deepcopy(kwbd)
  1360.             del kw['BUILDERS']
  1361.             self.__setitem__('BUILDERS', kwbd)
  1362.         kw = copy_non_reserved_keywords(kw)
  1363.         self._update(semi_deepcopy(kw))
  1364.         self.scanner_map_delete(kw)
  1365.     def ReplaceIxes(self, path, old_prefix, old_suffix, new_prefix, new_suffix):
  1366.         """
  1367.         Replace old_prefix with new_prefix and old_suffix with new_suffix.
  1368.         env - Environment used to interpolate variables.
  1369.         path - the path that will be modified.
  1370.         old_prefix - construction variable for the old prefix.
  1371.         old_suffix - construction variable for the old suffix.
  1372.         new_prefix - construction variable for the new prefix.
  1373.         new_suffix - construction variable for the new suffix.
  1374.         """
  1375.         old_prefix = self.subst('$'+old_prefix)
  1376.         old_suffix = self.subst('$'+old_suffix)
  1377.         new_prefix = self.subst('$'+new_prefix)
  1378.         new_suffix = self.subst('$'+new_suffix)
  1379.         dir,name = os.path.split(str(path))
  1380.         if name[:len(old_prefix)] == old_prefix:
  1381.             name = name[len(old_prefix):]
  1382.         if name[-len(old_suffix):] == old_suffix:
  1383.             name = name[:-len(old_suffix)]
  1384.         return os.path.join(dir, new_prefix+name+new_suffix)
  1385.     def SetDefault(self, **kw):
  1386.         for k in kw.keys():
  1387.             if self._dict.has_key(k):
  1388.                 del kw[k]
  1389.         apply(self.Replace, (), kw)
  1390.     def _find_toolpath_dir(self, tp):
  1391.         return self.fs.Dir(self.subst(tp)).srcnode().abspath
  1392.     def Tool(self, tool, toolpath=None, **kw):
  1393.         if SCons.Util.is_String(tool):
  1394.             tool = self.subst(tool)
  1395.             if toolpath is None:
  1396.                 toolpath = self.get('toolpath', [])
  1397.             toolpath = map(self._find_toolpath_dir, toolpath)
  1398.             tool = apply(SCons.Tool.Tool, (tool, toolpath), kw)
  1399.         tool(self)
  1400.     def WhereIs(self, prog, path=None, pathext=None, reject=[]):
  1401.         """Find prog in the path.
  1402.         """
  1403.         if path is None:
  1404.             try:
  1405.                 path = self['ENV']['PATH']
  1406.             except KeyError:
  1407.                 pass
  1408.         elif SCons.Util.is_String(path):
  1409.             path = self.subst(path)
  1410.         if pathext is None:
  1411.             try:
  1412.                 pathext = self['ENV']['PATHEXT']
  1413.             except KeyError:
  1414.                 pass
  1415.         elif SCons.Util.is_String(pathext):
  1416.             pathext = self.subst(pathext)
  1417.         path = SCons.Util.WhereIs(prog, path, pathext, reject)
  1418.         if path: return path
  1419.         return None
  1420.     #######################################################################
  1421.     # Public methods for doing real "SCons stuff" (manipulating
  1422.     # dependencies, setting attributes on targets, etc.).  These begin
  1423.     # with upper-case letters.  The essential characteristic of methods
  1424.     # in this section is that they all *should* have corresponding
  1425.     # same-named global functions.
  1426.     #######################################################################
  1427.     def Action(self, *args, **kw):
  1428.         def subst_string(a, self=self):
  1429.             if SCons.Util.is_String(a):
  1430.                 a = self.subst(a)
  1431.             return a
  1432.         nargs = map(subst_string, args)
  1433.         nkw = self.subst_kw(kw)
  1434.         return apply(SCons.Action.Action, nargs, nkw)
  1435.     def AddPreAction(self, files, action):
  1436.         nodes = self.arg2nodes(files, self.fs.Entry)
  1437.         action = SCons.Action.Action(action)
  1438.         uniq = {}
  1439.         for executor in map(lambda n: n.get_executor(), nodes):
  1440.             uniq[executor] = 1
  1441.         for executor in uniq.keys():
  1442.             executor.add_pre_action(action)
  1443.         return nodes
  1444.     def AddPostAction(self, files, action):
  1445.         nodes = self.arg2nodes(files, self.fs.Entry)
  1446.         action = SCons.Action.Action(action)
  1447.         uniq = {}
  1448.         for executor in map(lambda n: n.get_executor(), nodes):
  1449.             uniq[executor] = 1
  1450.         for executor in uniq.keys():
  1451.             executor.add_post_action(action)
  1452.         return nodes
  1453.     def Alias(self, target, source=[], action=None, **kw):
  1454.         tlist = self.arg2nodes(target, self.ans.Alias)
  1455.         if not SCons.Util.is_List(source):
  1456.             source = [source]
  1457.         source = filter(None, source)
  1458.         if not action:
  1459.             if not source:
  1460.                 # There are no source files and no action, so just
  1461.                 # return a target list of classic Alias Nodes, without
  1462.                 # any builder.  The externally visible effect is that
  1463.                 # this will make the wrapping Script.BuildTask class
  1464.                 # say that there's "Nothing to be done" for this Alias,
  1465.                 # instead of that it's "up to date."
  1466.                 return tlist
  1467.             # No action, but there are sources.  Re-call all the target
  1468.             # builders to add the sources to each target.
  1469.             result = []
  1470.             for t in tlist:
  1471.                 bld = t.get_builder(AliasBuilder)
  1472.                 result.extend(bld(self, t, source))
  1473.             return result
  1474.         nkw = self.subst_kw(kw)
  1475.         nkw.update({
  1476.             'action'            : SCons.Action.Action(action),
  1477.             'source_factory'    : self.fs.Entry,
  1478.             'multi'             : 1,
  1479.             'is_explicit'       : None,
  1480.         })
  1481.         bld = apply(SCons.Builder.Builder, (), nkw)
  1482.         # Apply the Builder separately to each target so that the Aliases
  1483.         # stay separate.  If we did one "normal" Builder call with the
  1484.         # whole target list, then all of the target Aliases would be
  1485.         # associated under a single Executor.
  1486.         result = []
  1487.         for t in tlist:
  1488.             # Calling the convert() method will cause a new Executor to be
  1489.             # created from scratch, so we have to explicitly initialize
  1490.             # it with the target's existing sources, plus our new ones,
  1491.             # so nothing gets lost.
  1492.             b = t.get_builder()
  1493.             if b is None or b is AliasBuilder:
  1494.                 b = bld
  1495.             else:
  1496.                 nkw['action'] = b.action + action
  1497.                 b = apply(SCons.Builder.Builder, (), nkw)
  1498.             t.convert()
  1499.             result.extend(b(self, t, t.sources + source))
  1500.         return result
  1501.     def AlwaysBuild(self, *targets):
  1502.         tlist = []
  1503.         for t in targets:
  1504.             tlist.extend(self.arg2nodes(t, self.fs.Entry))
  1505.         for t in tlist:
  1506.             t.set_always_build()
  1507.         return tlist
  1508.     def BuildDir(self, *args, **kw):
  1509.         if kw.has_key('build_dir'):
  1510.             kw['variant_dir'] = kw['build_dir']
  1511.             del kw['build_dir']
  1512.         return apply(self.VariantDir, args, kw)
  1513.     def Builder(self, **kw):
  1514.         nkw = self.subst_kw(kw)
  1515.         return apply(SCons.Builder.Builder, [], nkw)
  1516.     def CacheDir(self, path):
  1517.         import SCons.CacheDir
  1518.         if not path is None:
  1519.             path = self.subst(path)
  1520.         self._CacheDir_path = path
  1521.     def Clean(self, targets, files):
  1522.         global CleanTargets
  1523.         tlist = self.arg2nodes(targets, self.fs.Entry)
  1524.         flist = self.arg2nodes(files, self.fs.Entry)
  1525.         for t in tlist:
  1526.             try:
  1527.                 CleanTargets[t].extend(flist)
  1528.             except KeyError:
  1529.                 CleanTargets[t] = flist
  1530.     def Configure(self, *args, **kw):
  1531.         nargs = [self]
  1532.         if args:
  1533.             nargs = nargs + self.subst_list(args)[0]
  1534.         nkw = self.subst_kw(kw)
  1535.         nkw['_depth'] = kw.get('_depth', 0) + 1
  1536.         try:
  1537.             nkw['custom_tests'] = self.subst_kw(nkw['custom_tests'])
  1538.         except KeyError:
  1539.             pass
  1540.         return apply(SCons.SConf.SConf, nargs, nkw)
  1541.     def Command(self, target, source, action, **kw):
  1542.         """Builds the supplied target files from the supplied
  1543.         source files using the supplied action.  Action may
  1544.         be any type that the Builder constructor will accept
  1545.         for an action."""
  1546.         bkw = {
  1547.             'action' : action,
  1548.             'target_factory' : self.fs.Entry,
  1549.             'source_factory' : self.fs.Entry,
  1550.         }
  1551.         try: bkw['source_scanner'] = kw['source_scanner']
  1552.         except KeyError: pass
  1553.         else: del kw['source_scanner']
  1554.         bld = apply(SCons.Builder.Builder, (), bkw)
  1555.         return apply(bld, (self, target, source), kw)
  1556.     def Depends(self, target, dependency):
  1557.         """Explicity specify that 'target's depend on 'dependency'."""
  1558.         tlist = self.arg2nodes(target, self.fs.Entry)
  1559.         dlist = self.arg2nodes(dependency, self.fs.Entry)
  1560.         for t in tlist:
  1561.             t.add_dependency(dlist)
  1562.         return tlist
  1563.     def Dir(self, name, *args, **kw):
  1564.         """
  1565.         """
  1566.         s = self.subst(name)
  1567.         if SCons.Util.is_Sequence(s):
  1568.             result=[]
  1569.             for e in s:
  1570.                 result.append(apply(self.fs.Dir, (e,) + args, kw))
  1571.             return result
  1572.         return apply(self.fs.Dir, (s,) + args, kw)
  1573.     def NoClean(self, *targets):
  1574.         """Tags a target so that it will not be cleaned by -c"""
  1575.         tlist = []
  1576.         for t in targets:
  1577.             tlist.extend(self.arg2nodes(t, self.fs.Entry))
  1578.         for t in tlist:
  1579.             t.set_noclean()
  1580.         return tlist
  1581.     def NoCache(self, *targets):
  1582.         """Tags a target so that it will not be cached"""
  1583.         tlist = []
  1584.         for t in targets:
  1585.             tlist.extend(self.arg2nodes(t, self.fs.Entry))
  1586.         for t in tlist:
  1587.             t.set_nocache()
  1588.         return tlist
  1589.     def Entry(self, name, *args, **kw):
  1590.         """
  1591.         """
  1592.         s = self.subst(name)
  1593.         if SCons.Util.is_Sequence(s):
  1594.             result=[]
  1595.             for e in s:
  1596.                 result.append(apply(self.fs.Entry, (e,) + args, kw))
  1597.             return result
  1598.         return apply(self.fs.Entry, (s,) + args, kw)
  1599.     def Environment(self, **kw):
  1600.         return apply(SCons.Environment.Environment, [], self.subst_kw(kw))
  1601.     def Execute(self, action, *args, **kw):
  1602.         """Directly execute an action through an Environment
  1603.         """
  1604.         action = apply(self.Action, (action,) + args, kw)
  1605.         result = action([], [], self)
  1606.         if isinstance(result, SCons.Errors.BuildError):
  1607.             return result.status
  1608.         else:
  1609.             return result
  1610.     def File(self, name, *args, **kw):
  1611.         """
  1612.         """
  1613.         s = self.subst(name)
  1614.         if SCons.Util.is_Sequence(s):
  1615.             result=[]
  1616.             for e in s:
  1617.                 result.append(apply(self.fs.File, (e,) + args, kw))
  1618.             return result
  1619.         return apply(self.fs.File, (s,) + args, kw)
  1620.     def FindFile(self, file, dirs):
  1621.         file = self.subst(file)
  1622.         nodes = self.arg2nodes(dirs, self.fs.Dir)
  1623.         return SCons.Node.FS.find_file(file, tuple(nodes))
  1624.     def Flatten(self, sequence):
  1625.         return SCons.Util.flatten(sequence)
  1626.     def GetBuildPath(self, files):
  1627.         result = map(str, self.arg2nodes(files, self.fs.Entry))
  1628.         if SCons.Util.is_List(files):
  1629.             return result
  1630.         else:
  1631.             return result[0]
  1632.     def Glob(self, pattern, ondisk=True, source=False, strings=False):
  1633.         return self.fs.Glob(self.subst(pattern), ondisk, source, strings)
  1634.     def Ignore(self, target, dependency):
  1635.         """Ignore a dependency."""
  1636.         tlist = self.arg2nodes(target, self.fs.Entry)
  1637.         dlist = self.arg2nodes(dependency, self.fs.Entry)
  1638.         for t in tlist:
  1639.             t.add_ignore(dlist)
  1640.         return tlist
  1641.     def Literal(self, string):
  1642.         return SCons.Subst.Literal(string)
  1643.     def Local(self, *targets):
  1644.         ret = []
  1645.         for targ in targets:
  1646.             if isinstance(targ, SCons.Node.Node):
  1647.                 targ.set_local()
  1648.                 ret.append(targ)
  1649.             else:
  1650.                 for t in self.arg2nodes(targ, self.fs.Entry):
  1651.                    t.set_local()
  1652.                    ret.append(t)
  1653.         return ret
  1654.     def Precious(self, *targets):
  1655.         tlist = []
  1656.         for t in targets:
  1657.             tlist.extend(self.arg2nodes(t, self.fs.Entry))
  1658.         for t in tlist:
  1659.             t.set_precious()
  1660.         return tlist
  1661.     def Repository(self, *dirs, **kw):
  1662.         dirs = self.arg2nodes(list(dirs), self.fs.Dir)
  1663.         apply(self.fs.Repository, dirs, kw)
  1664.     def Requires(self, target, prerequisite):
  1665.         """Specify that 'prerequisite' must be built before 'target',
  1666.         (but 'target' does not actually depend on 'prerequisite'
  1667.         and need not be rebuilt if it changes)."""
  1668.         tlist = self.arg2nodes(target, self.fs.Entry)
  1669.         plist = self.arg2nodes(prerequisite, self.fs.Entry)
  1670.         for t in tlist:
  1671.             t.add_prerequisite(plist)
  1672.         return tlist
  1673.     def Scanner(self, *args, **kw):
  1674.         nargs = []
  1675.         for arg in args:
  1676.             if SCons.Util.is_String(arg):
  1677.                 arg = self.subst(arg)
  1678.             nargs.append(arg)
  1679.         nkw = self.subst_kw(kw)
  1680.         return apply(SCons.Scanner.Base, nargs, nkw)
  1681.     def SConsignFile(self, name=".sconsign", dbm_module=None):
  1682.         if not name is None:
  1683.             name = self.subst(name)
  1684.             if not os.path.isabs(name):
  1685.                 name = os.path.join(str(self.fs.SConstruct_dir), name)
  1686.         SCons.SConsign.File(name, dbm_module)
  1687.     def SideEffect(self, side_effect, target):
  1688.         """Tell scons that side_effects are built as side
  1689.         effects of building targets."""
  1690.         side_effects = self.arg2nodes(side_effect, self.fs.Entry)
  1691.         targets = self.arg2nodes(target, self.fs.Entry)
  1692.         for side_effect in side_effects:
  1693.             if side_effect.multiple_side_effect_has_builder():
  1694.                 raise SCons.Errors.UserError, "Multiple ways to build the same target were specified for: %s" % str(side_effect)
  1695.             side_effect.add_source(targets)
  1696.             side_effect.side_effect = 1
  1697.             self.Precious(side_effect)
  1698.             for target in targets:
  1699.                 target.side_effects.append(side_effect)
  1700.         return side_effects
  1701.     def SourceCode(self, entry, builder):
  1702.         """Arrange for a source code builder for (part of) a tree."""
  1703.         entries = self.arg2nodes(entry, self.fs.Entry)
  1704.         for entry in entries:
  1705.             entry.set_src_builder(builder)
  1706.         return entries
  1707.     def SourceSignatures(self, type):
  1708.         global _warn_source_signatures_deprecated
  1709.         if _warn_source_signatures_deprecated:
  1710.             msg = "The env.SourceSignatures() method is deprecated;n" + 
  1711.                   "tconvert your build to use the env.Decider() method instead."
  1712.             SCons.Warnings.warn(SCons.Warnings.DeprecatedSourceSignaturesWarning, msg)
  1713.             _warn_source_signatures_deprecated = False
  1714.         type = self.subst(type)
  1715.         self.src_sig_type = type
  1716.         if type == 'MD5':
  1717.             if not SCons.Util.md5:
  1718.                 raise UserError, "MD5 signatures are not available in this version of Python."
  1719.             self.decide_source = self._changed_content
  1720.         elif type == 'timestamp':
  1721.             self.decide_source = self._changed_timestamp_match
  1722.         else:
  1723.             raise UserError, "Unknown source signature type '%s'" % type
  1724.     def Split(self, arg):
  1725.         """This function converts a string or list into a list of strings
  1726.         or Nodes.  This makes things easier for users by allowing files to
  1727.         be specified as a white-space separated list to be split.
  1728.         The input rules are:
  1729.             - A single string containing names separated by spaces. These will be
  1730.               split apart at the spaces.
  1731.             - A single Node instance
  1732.             - A list containing either strings or Node instances. Any strings
  1733.               in the list are not split at spaces.
  1734.         In all cases, the function returns a list of Nodes and strings."""
  1735.         if SCons.Util.is_List(arg):
  1736.             return map(self.subst, arg)
  1737.         elif SCons.Util.is_String(arg):
  1738.             return string.split(self.subst(arg))
  1739.         else:
  1740.             return [self.subst(arg)]
  1741.     def TargetSignatures(self, type):
  1742.         global _warn_target_signatures_deprecated
  1743.         if _warn_target_signatures_deprecated:
  1744.             msg = "The env.TargetSignatures() method is deprecated;n" + 
  1745.                   "tconvert your build to use the env.Decider() method instead."
  1746.             SCons.Warnings.warn(SCons.Warnings.DeprecatedTargetSignaturesWarning, msg)
  1747.             _warn_target_signatures_deprecated = False
  1748.         type = self.subst(type)
  1749.         self.tgt_sig_type = type
  1750.         if type in ('MD5', 'content'):
  1751.             if not SCons.Util.md5:
  1752.                 raise UserError, "MD5 signatures are not available in this version of Python."
  1753.             self.decide_target = self._changed_content
  1754.         elif type == 'timestamp':
  1755.             self.decide_target = self._changed_timestamp_match
  1756.         elif type == 'build':
  1757.             self.decide_target = self._changed_build
  1758.         elif type == 'source':
  1759.             self.decide_target = self._changed_source
  1760.         else:
  1761.             raise UserError, "Unknown target signature type '%s'"%type
  1762.     def Value(self, value, built_value=None):
  1763.         """
  1764.         """
  1765.         return SCons.Node.Python.Value(value, built_value)
  1766.     def VariantDir(self, variant_dir, src_dir, duplicate=1):
  1767.         variant_dir = self.arg2nodes(variant_dir, self.fs.Dir)[0]
  1768.         src_dir = self.arg2nodes(src_dir, self.fs.Dir)[0]
  1769.         self.fs.VariantDir(variant_dir, src_dir, duplicate)
  1770.     def FindSourceFiles(self, node='.'):
  1771.         """ returns a list of all source files.
  1772.         """
  1773.         node = self.arg2nodes(node, self.fs.Entry)[0]
  1774.         sources = []
  1775.         # Uncomment this and get rid of the global definition when we
  1776.         # drop support for pre-2.2 Python versions.
  1777.         #def build_source(ss, result):
  1778.         #    for s in ss:
  1779.         #        if isinstance(s, SCons.Node.FS.Dir):
  1780.         #            build_source(s.all_children(), result)
  1781.         #        elif s.has_builder():
  1782.         #            build_source(s.sources, result)
  1783.         #        elif isinstance(s.disambiguate(), SCons.Node.FS.File):
  1784.         #            result.append(s)
  1785.         build_source(node.all_children(), sources)
  1786.         # now strip the build_node from the sources by calling the srcnode
  1787.         # function
  1788.         def get_final_srcnode(file):
  1789.             srcnode = file.srcnode()
  1790.             while srcnode != file.srcnode():
  1791.                 srcnode = file.srcnode()
  1792.             return srcnode
  1793.         # get the final srcnode for all nodes, this means stripping any
  1794.         # attached build node.
  1795.         map( get_final_srcnode, sources )
  1796.         # remove duplicates
  1797.         return list(set(sources))
  1798.     def FindInstalledFiles(self):
  1799.         """ returns the list of all targets of the Install and InstallAs Builder.
  1800.         """
  1801.         from SCons.Tool import install
  1802.         if install._UNIQUE_INSTALLED_FILES is None:
  1803.             install._UNIQUE_INSTALLED_FILES = SCons.Util.uniquer_hashables(install._INSTALLED_FILES)
  1804.         return install._UNIQUE_INSTALLED_FILES
  1805. class OverrideEnvironment(Base):
  1806.     """A proxy that overrides variables in a wrapped construction
  1807.     environment by returning values from an overrides dictionary in
  1808.     preference to values from the underlying subject environment.
  1809.     This is a lightweight (I hope) proxy that passes through most use of
  1810.     attributes to the underlying Environment.Base class, but has just
  1811.     enough additional methods defined to act like a real construction
  1812.     environment with overridden values.  It can wrap either a Base
  1813.     construction environment, or another OverrideEnvironment, which
  1814.     can in turn nest arbitrary OverrideEnvironments...
  1815.     Note that we do *not* call the underlying base class
  1816.     (SubsitutionEnvironment) initialization, because we get most of those
  1817.     from proxying the attributes of the subject construction environment.
  1818.     But because we subclass SubstitutionEnvironment, this class also
  1819.     has inherited arg2nodes() and subst*() methods; those methods can't
  1820.     be proxied because they need *this* object's methods to fetch the
  1821.     values from the overrides dictionary.
  1822.     """
  1823.     if SCons.Memoize.use_memoizer:
  1824.         __metaclass__ = SCons.Memoize.Memoized_Metaclass
  1825.     def __init__(self, subject, overrides={}):
  1826.         if __debug__: logInstanceCreation(self, 'Environment.OverrideEnvironment')
  1827.         self.__dict__['__subject'] = subject
  1828.         self.__dict__['overrides'] = overrides
  1829.     # Methods that make this class act like a proxy.
  1830.     def __getattr__(self, name):
  1831.         return getattr(self.__dict__['__subject'], name)
  1832.     def __setattr__(self, name, value):
  1833.         setattr(self.__dict__['__subject'], name, value)
  1834.     # Methods that make this class act like a dictionary.
  1835.     def __getitem__(self, key):
  1836.         try:
  1837.             return self.__dict__['overrides'][key]
  1838.         except KeyError:
  1839.             return self.__dict__['__subject'].__getitem__(key)
  1840.     def __setitem__(self, key, value):
  1841.         if not is_valid_construction_var(key):
  1842.             raise SCons.Errors.UserError, "Illegal construction variable `%s'" % key
  1843.         self.__dict__['overrides'][key] = value
  1844.     def __delitem__(self, key):
  1845.         try:
  1846.             del self.__dict__['overrides'][key]
  1847.         except KeyError:
  1848.             deleted = 0
  1849.         else:
  1850.             deleted = 1
  1851.         try:
  1852.             result = self.__dict__['__subject'].__delitem__(key)
  1853.         except KeyError:
  1854.             if not deleted:
  1855.                 raise
  1856.             result = None
  1857.         return result
  1858.     def get(self, key, default=None):
  1859.         """Emulates the get() method of dictionaries."""
  1860.         try:
  1861.             return self.__dict__['overrides'][key]
  1862.         except KeyError:
  1863.             return self.__dict__['__subject'].get(key, default)
  1864.     def has_key(self, key):
  1865.         try:
  1866.             self.__dict__['overrides'][key]
  1867.             return 1
  1868.         except KeyError:
  1869.             return self.__dict__['__subject'].has_key(key)
  1870.     def Dictionary(self):
  1871.         """Emulates the items() method of dictionaries."""
  1872.         d = self.__dict__['__subject'].Dictionary().copy()
  1873.         d.update(self.__dict__['overrides'])
  1874.         return d
  1875.     def items(self):
  1876.         """Emulates the items() method of dictionaries."""
  1877.         return self.Dictionary().items()
  1878.     # Overridden private construction environment methods.
  1879.     def _update(self, dict):
  1880.         """Update an environment's values directly, bypassing the normal
  1881.         checks that occur when users try to set items.
  1882.         """
  1883.         self.__dict__['overrides'].update(dict)
  1884.     def gvars(self):
  1885.         return self.__dict__['__subject'].gvars()
  1886.     def lvars(self):
  1887.         lvars = self.__dict__['__subject'].lvars()
  1888.         lvars.update(self.__dict__['overrides'])
  1889.         return lvars
  1890.     # Overridden public construction environment methods.
  1891.     def Replace(self, **kw):
  1892.         kw = copy_non_reserved_keywords(kw)
  1893.         self.__dict__['overrides'].update(semi_deepcopy(kw))
  1894. # The entry point that will be used by the external world
  1895. # to refer to a construction environment.  This allows the wrapper
  1896. # interface to extend a construction environment for its own purposes
  1897. # by subclassing SCons.Environment.Base and then assigning the
  1898. # class to SCons.Environment.Environment.
  1899. Environment = Base
  1900. # An entry point for returning a proxy subclass instance that overrides
  1901. # the subst*() methods so they don't actually perform construction
  1902. # variable substitution.  This is specifically intended to be the shim
  1903. # layer in between global function calls (which don't want construction
  1904. # variable substitution) and the DefaultEnvironment() (which would
  1905. # substitute variables if left to its own devices)."""
  1906. #
  1907. # We have to wrap this in a function that allows us to delay definition of
  1908. # the class until it's necessary, so that when it subclasses Environment
  1909. # it will pick up whatever Environment subclass the wrapper interface
  1910. # might have assigned to SCons.Environment.Environment.
  1911. def NoSubstitutionProxy(subject):
  1912.     class _NoSubstitutionProxy(Environment):
  1913.         def __init__(self, subject):
  1914.             self.__dict__['__subject'] = subject
  1915.         def __getattr__(self, name):
  1916.             return getattr(self.__dict__['__subject'], name)
  1917.         def __setattr__(self, name, value):
  1918.             return setattr(self.__dict__['__subject'], name, value)
  1919.         def raw_to_mode(self, dict):
  1920.             try:
  1921.                 raw = dict['raw']
  1922.             except KeyError:
  1923.                 pass
  1924.             else:
  1925.                 del dict['raw']
  1926.                 dict['mode'] = raw
  1927.         def subst(self, string, *args, **kwargs):
  1928.             return string
  1929.         def subst_kw(self, kw, *args, **kwargs):
  1930.             return kw
  1931.         def subst_list(self, string, *args, **kwargs):
  1932.             nargs = (string, self,) + args
  1933.             nkw = kwargs.copy()
  1934.             nkw['gvars'] = {}
  1935.             self.raw_to_mode(nkw)
  1936.             return apply(SCons.Subst.scons_subst_list, nargs, nkw)
  1937.         def subst_target_source(self, string, *args, **kwargs):
  1938.             nargs = (string, self,) + args
  1939.             nkw = kwargs.copy()
  1940.             nkw['gvars'] = {}
  1941.             self.raw_to_mode(nkw)
  1942.             return apply(SCons.Subst.scons_subst, nargs, nkw)
  1943.     return _NoSubstitutionProxy(subject)