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

外挂编程

开发平台:

Windows_Unix

  1. """SCons.Builder
  2. Builder object subsystem.
  3. A Builder object is a callable that encapsulates information about how
  4. to execute actions to create a target Node (file) from source Nodes
  5. (files), and how to create those dependencies for tracking.
  6. The main entry point here is the Builder() factory method.  This provides
  7. a procedural interface that creates the right underlying Builder object
  8. based on the keyword arguments supplied and the types of the arguments.
  9. The goal is for this external interface to be simple enough that the
  10. vast majority of users can create new Builders as necessary to support
  11. building new types of files in their configurations, without having to
  12. dive any deeper into this subsystem.
  13. The base class here is BuilderBase.  This is a concrete base class which
  14. does, in fact, represent the Builder objects that we (or users) create.
  15. There is also a proxy that looks like a Builder:
  16.     CompositeBuilder
  17.         This proxies for a Builder with an action that is actually a
  18.         dictionary that knows how to map file suffixes to a specific
  19.         action.  This is so that we can invoke different actions
  20.         (compilers, compile options) for different flavors of source
  21.         files.
  22. Builders and their proxies have the following public interface methods
  23. used by other modules:
  24.     __call__()
  25.         THE public interface.  Calling a Builder object (with the
  26.         use of internal helper methods) sets up the target and source
  27.         dependencies, appropriate mapping to a specific action, and the
  28.         environment manipulation necessary for overridden construction
  29.         variable.  This also takes care of warning about possible mistakes
  30.         in keyword arguments.
  31.     add_emitter()
  32.         Adds an emitter for a specific file suffix, used by some Tool
  33.         modules to specify that (for example) a yacc invocation on a .y
  34.         can create a .h *and* a .c file.
  35.     add_action()
  36.         Adds an action for a specific file suffix, heavily used by
  37.         Tool modules to add their specific action(s) for turning
  38.         a source file into an object file to the global static
  39.         and shared object file Builders.
  40. There are the following methods for internal use within this module:
  41.     _execute()
  42.         The internal method that handles the heavily lifting when a
  43.         Builder is called.  This is used so that the __call__() methods
  44.         can set up warning about possible mistakes in keyword-argument
  45.         overrides, and *then* execute all of the steps necessary so that
  46.         the warnings only occur once.
  47.     get_name()
  48.         Returns the Builder's name within a specific Environment,
  49.         primarily used to try to return helpful information in error
  50.         messages.
  51.     adjust_suffix()
  52.     get_prefix()
  53.     get_suffix()
  54.     get_src_suffix()
  55.     set_src_suffix()
  56.         Miscellaneous stuff for handling the prefix and suffix
  57.         manipulation we use in turning source file names into target
  58.         file names.
  59. """
  60. #
  61. # Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation
  62. #
  63. # Permission is hereby granted, free of charge, to any person obtaining
  64. # a copy of this software and associated documentation files (the
  65. # "Software"), to deal in the Software without restriction, including
  66. # without limitation the rights to use, copy, modify, merge, publish,
  67. # distribute, sublicense, and/or sell copies of the Software, and to
  68. # permit persons to whom the Software is furnished to do so, subject to
  69. # the following conditions:
  70. #
  71. # The above copyright notice and this permission notice shall be included
  72. # in all copies or substantial portions of the Software.
  73. #
  74. # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  75. # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  76. # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  77. # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  78. # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  79. # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  80. # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  81. #
  82. __revision__ = "src/engine/SCons/Builder.py 3057 2008/06/09 22:21:00 knight"
  83. import SCons.compat
  84. import UserDict
  85. import UserList
  86. import SCons.Action
  87. from SCons.Debug import logInstanceCreation
  88. from SCons.Errors import InternalError, UserError
  89. import SCons.Executor
  90. import SCons.Memoize
  91. import SCons.Node
  92. import SCons.Node.FS
  93. import SCons.Util
  94. import SCons.Warnings
  95. class _Null:
  96.     pass
  97. _null = _Null
  98. class DictCmdGenerator(SCons.Util.Selector):
  99.     """This is a callable class that can be used as a
  100.     command generator function.  It holds on to a dictionary
  101.     mapping file suffixes to Actions.  It uses that dictionary
  102.     to return the proper action based on the file suffix of
  103.     the source file."""
  104.     def __init__(self, dict=None, source_ext_match=1):
  105.         SCons.Util.Selector.__init__(self, dict)
  106.         self.source_ext_match = source_ext_match
  107.     def src_suffixes(self):
  108.         return self.keys()
  109.     def add_action(self, suffix, action):
  110.         """Add a suffix-action pair to the mapping.
  111.         """
  112.         self[suffix] = action
  113.     def __call__(self, target, source, env, for_signature):
  114.         if not source:
  115.             return []
  116.         if self.source_ext_match:
  117.             ext = None
  118.             for src in map(str, source):
  119.                 my_ext = SCons.Util.splitext(src)[1]
  120.                 if ext and my_ext != ext:
  121.                     raise UserError("While building `%s' from `%s': Cannot build multiple sources with different extensions: %s, %s" % (repr(map(str, target)), src, ext, my_ext))
  122.                 ext = my_ext
  123.         else:
  124.             ext = SCons.Util.splitext(str(source[0]))[1]
  125.         if not ext:
  126.             raise UserError("While building `%s': Cannot deduce file extension from source files: %s" % (repr(map(str, target)), repr(map(str, source))))
  127.         try:
  128.             ret = SCons.Util.Selector.__call__(self, env, source)
  129.         except KeyError, e:
  130.             raise UserError("Ambiguous suffixes after environment substitution: %s == %s == %s" % (e[0], e[1], e[2]))
  131.         if ret is None:
  132.             raise UserError("While building `%s' from `%s': Don't know how to build from a source file with suffix `%s'.  Expected a suffix in this list: %s." % 
  133.                             (repr(map(str, target)), repr(map(str, source)), ext, repr(self.keys())))
  134.         return ret
  135. class CallableSelector(SCons.Util.Selector):
  136.     """A callable dictionary that will, in turn, call the value it
  137.     finds if it can."""
  138.     def __call__(self, env, source):
  139.         value = SCons.Util.Selector.__call__(self, env, source)
  140.         if callable(value):
  141.             value = value(env, source)
  142.         return value
  143. class DictEmitter(SCons.Util.Selector):
  144.     """A callable dictionary that maps file suffixes to emitters.
  145.     When called, it finds the right emitter in its dictionary for the
  146.     suffix of the first source file, and calls that emitter to get the
  147.     right lists of targets and sources to return.  If there's no emitter
  148.     for the suffix in its dictionary, the original target and source are
  149.     returned.
  150.     """
  151.     def __call__(self, target, source, env):
  152.         emitter = SCons.Util.Selector.__call__(self, env, source)
  153.         if emitter:
  154.             target, source = emitter(target, source, env)
  155.         return (target, source)
  156. class ListEmitter(UserList.UserList):
  157.     """A callable list of emitters that calls each in sequence,
  158.     returning the result.
  159.     """
  160.     def __call__(self, target, source, env):
  161.         for e in self.data:
  162.             target, source = e(target, source, env)
  163.         return (target, source)
  164. # These are a common errors when calling a Builder;
  165. # they are similar to the 'target' and 'source' keyword args to builders,
  166. # so we issue warnings when we see them.  The warnings can, of course,
  167. # be disabled.
  168. misleading_keywords = {
  169.     'targets'   : 'target',
  170.     'sources'   : 'source',
  171. }
  172. class OverrideWarner(UserDict.UserDict):
  173.     """A class for warning about keyword arguments that we use as
  174.     overrides in a Builder call.
  175.     This class exists to handle the fact that a single Builder call
  176.     can actually invoke multiple builders.  This class only emits the
  177.     warnings once, no matter how many Builders are invoked.
  178.     """
  179.     def __init__(self, dict):
  180.         UserDict.UserDict.__init__(self, dict)
  181.         if __debug__: logInstanceCreation(self, 'Builder.OverrideWarner')
  182.         self.already_warned = None
  183.     def warn(self):
  184.         if self.already_warned:
  185.             return
  186.         for k in self.keys():
  187.             if misleading_keywords.has_key(k):
  188.                 alt = misleading_keywords[k]
  189.                 msg = "Did you mean to use `%s' instead of `%s'?" % (alt, k)
  190.                 SCons.Warnings.warn(SCons.Warnings.MisleadingKeywordsWarning, msg)
  191.         self.already_warned = 1
  192. def Builder(**kw):
  193.     """A factory for builder objects."""
  194.     composite = None
  195.     if kw.has_key('generator'):
  196.         if kw.has_key('action'):
  197.             raise UserError, "You must not specify both an action and a generator."
  198.         kw['action'] = SCons.Action.CommandGeneratorAction(kw['generator'])
  199.         del kw['generator']
  200.     elif kw.has_key('action'):
  201.         source_ext_match = kw.get('source_ext_match', 1)
  202.         if kw.has_key('source_ext_match'):
  203.             del kw['source_ext_match']
  204.         if SCons.Util.is_Dict(kw['action']):
  205.             composite = DictCmdGenerator(kw['action'], source_ext_match)
  206.             kw['action'] = SCons.Action.CommandGeneratorAction(composite)
  207.             kw['src_suffix'] = composite.src_suffixes()
  208.         else:
  209.             kw['action'] = SCons.Action.Action(kw['action'])
  210.     if kw.has_key('emitter'):
  211.         emitter = kw['emitter']
  212.         if SCons.Util.is_String(emitter):
  213.             # This allows users to pass in an Environment
  214.             # variable reference (like "$FOO") as an emitter.
  215.             # We will look in that Environment variable for
  216.             # a callable to use as the actual emitter.
  217.             var = SCons.Util.get_environment_var(emitter)
  218.             if not var:
  219.                 raise UserError, "Supplied emitter '%s' does not appear to refer to an Environment variable" % emitter
  220.             kw['emitter'] = EmitterProxy(var)
  221.         elif SCons.Util.is_Dict(emitter):
  222.             kw['emitter'] = DictEmitter(emitter)
  223.         elif SCons.Util.is_List(emitter):
  224.             kw['emitter'] = ListEmitter(emitter)
  225.     result = apply(BuilderBase, (), kw)
  226.     if not composite is None:
  227.         result = CompositeBuilder(result, composite)
  228.     return result
  229. def _node_errors(builder, env, tlist, slist):
  230.     """Validate that the lists of target and source nodes are
  231.     legal for this builder and environment.  Raise errors or
  232.     issue warnings as appropriate.
  233.     """
  234.     # First, figure out if there are any errors in the way the targets
  235.     # were specified.
  236.     for t in tlist:
  237.         if t.side_effect:
  238.             raise UserError, "Multiple ways to build the same target were specified for: %s" % t
  239.         if t.has_explicit_builder():
  240.             if not t.env is None and not t.env is env:
  241.                 action = t.builder.action
  242.                 t_contents = action.get_contents(tlist, slist, t.env)
  243.                 contents = action.get_contents(tlist, slist, env)
  244.                 if t_contents == contents:
  245.                     msg = "Two different environments were specified for target %s,ntbut they appear to have the same action: %s" % (t, action.genstring(tlist, slist, t.env))
  246.                     SCons.Warnings.warn(SCons.Warnings.DuplicateEnvironmentWarning, msg)
  247.                 else:
  248.                     msg = "Two environments with different actions were specified for the same target: %s" % t
  249.                     raise UserError, msg
  250.             if builder.multi:
  251.                 if t.builder != builder:
  252.                     msg = "Two different builders (%s and %s) were specified for the same target: %s" % (t.builder.get_name(env), builder.get_name(env), t)
  253.                     raise UserError, msg
  254.                 if t.get_executor().targets != tlist:
  255.                     msg = "Two different target lists have a target in common: %s  (from %s and from %s)" % (t, map(str, t.get_executor().targets), map(str, tlist))
  256.                     raise UserError, msg
  257.             elif t.sources != slist:
  258.                 msg = "Multiple ways to build the same target were specified for: %s  (from %s and from %s)" % (t, map(str, t.sources), map(str, slist))
  259.                 raise UserError, msg
  260.     if builder.single_source:
  261.         if len(slist) > 1:
  262.             raise UserError, "More than one source given for single-source builder: targets=%s sources=%s" % (map(str,tlist), map(str,slist))
  263. class EmitterProxy:
  264.     """This is a callable class that can act as a
  265.     Builder emitter.  It holds on to a string that
  266.     is a key into an Environment dictionary, and will
  267.     look there at actual build time to see if it holds
  268.     a callable.  If so, we will call that as the actual
  269.     emitter."""
  270.     def __init__(self, var):
  271.         self.var = SCons.Util.to_String(var)
  272.     def __call__(self, target, source, env):
  273.         emitter = self.var
  274.         # Recursively substitute the variable.
  275.         # We can't use env.subst() because it deals only
  276.         # in strings.  Maybe we should change that?
  277.         while SCons.Util.is_String(emitter) and env.has_key(emitter):
  278.             emitter = env[emitter]
  279.         if callable(emitter):
  280.             target, source = emitter(target, source, env)
  281.         elif SCons.Util.is_List(emitter):
  282.             for e in emitter:
  283.                 target, source = e(target, source, env)
  284.         return (target, source)
  285.     def __cmp__(self, other):
  286.         return cmp(self.var, other.var)
  287. class BuilderBase:
  288.     """Base class for Builders, objects that create output
  289.     nodes (files) from input nodes (files).
  290.     """
  291.     if SCons.Memoize.use_memoizer:
  292.         __metaclass__ = SCons.Memoize.Memoized_Metaclass
  293.     memoizer_counters = []
  294.     def __init__(self,  action = None,
  295.                         prefix = '',
  296.                         suffix = '',
  297.                         src_suffix = '',
  298.                         target_factory = None,
  299.                         source_factory = None,
  300.                         target_scanner = None,
  301.                         source_scanner = None,
  302.                         emitter = None,
  303.                         multi = 0,
  304.                         env = None,
  305.                         single_source = 0,
  306.                         name = None,
  307.                         chdir = _null,
  308.                         is_explicit = 1,
  309.                         src_builder = [],
  310.                         ensure_suffix = False,
  311.                         **overrides):
  312.         if __debug__: logInstanceCreation(self, 'Builder.BuilderBase')
  313.         self._memo = {}
  314.         self.action = action
  315.         self.multi = multi
  316.         if SCons.Util.is_Dict(prefix):
  317.             prefix = CallableSelector(prefix)
  318.         self.prefix = prefix
  319.         if SCons.Util.is_Dict(suffix):
  320.             suffix = CallableSelector(suffix)
  321.         self.env = env
  322.         self.single_source = single_source
  323.         if overrides.has_key('overrides'):
  324.             SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
  325.                 "The "overrides" keyword to Builder() creation has been deprecated;n" +
  326.                 "tspecify the items as keyword arguments to the Builder() call instead.")
  327.             overrides.update(overrides['overrides'])
  328.             del overrides['overrides']
  329.         if overrides.has_key('scanner'):
  330.             SCons.Warnings.warn(SCons.Warnings.DeprecatedWarning,
  331.                                 "The "scanner" keyword to Builder() creation has been deprecated;n"
  332.                                 "tuse: source_scanner or target_scanner as appropriate.")
  333.             del overrides['scanner']
  334.         self.overrides = overrides
  335.         self.set_suffix(suffix)
  336.         self.set_src_suffix(src_suffix)
  337.         self.ensure_suffix = ensure_suffix
  338.         self.target_factory = target_factory
  339.         self.source_factory = source_factory
  340.         self.target_scanner = target_scanner
  341.         self.source_scanner = source_scanner
  342.         self.emitter = emitter
  343.         # Optional Builder name should only be used for Builders
  344.         # that don't get attached to construction environments.
  345.         if name:
  346.             self.name = name
  347.         self.executor_kw = {}
  348.         if not chdir is _null:
  349.             self.executor_kw['chdir'] = chdir
  350.         self.is_explicit = is_explicit
  351.         if not SCons.Util.is_List(src_builder):
  352.             src_builder = [ src_builder ]
  353.         self.src_builder = src_builder
  354.     def __nonzero__(self):
  355.         raise InternalError, "Do not test for the Node.builder attribute directly; use Node.has_builder() instead"
  356.     def get_name(self, env):
  357.         """Attempts to get the name of the Builder.
  358.         Look at the BUILDERS variable of env, expecting it to be a
  359.         dictionary containing this Builder, and return the key of the
  360.         dictionary.  If there's no key, then return a directly-configured
  361.         name (if there is one) or the name of the class (by default)."""
  362.         try:
  363.             index = env['BUILDERS'].values().index(self)
  364.             return env['BUILDERS'].keys()[index]
  365.         except (AttributeError, KeyError, TypeError, ValueError):
  366.             try:
  367.                 return self.name
  368.             except AttributeError:
  369.                 return str(self.__class__)
  370.     def __cmp__(self, other):
  371.         return cmp(self.__dict__, other.__dict__)
  372.     def splitext(self, path, env=None):
  373.         if not env:
  374.             env = self.env
  375.         if env:
  376.             matchsuf = filter(lambda S,path=path: path[-len(S):] == S,
  377.                               self.src_suffixes(env))
  378.             if matchsuf:
  379.                 suf = max(map(None, map(len, matchsuf), matchsuf))[1]
  380.                 return [path[:-len(suf)], path[-len(suf):]]
  381.         return SCons.Util.splitext(path)
  382.     def get_single_executor(self, env, tlist, slist, executor_kw):
  383.         if not self.action:
  384.             raise UserError, "Builder %s must have an action to build %s."%(self.get_name(env or self.env), map(str,tlist))
  385.         return self.action.get_executor(env or self.env,
  386.                                         [],  # env already has overrides
  387.                                         tlist,
  388.                                         slist,
  389.                                         executor_kw)
  390.     def get_multi_executor(self, env, tlist, slist, executor_kw):
  391.         try:
  392.             executor = tlist[0].get_executor(create = 0)
  393.         except (AttributeError, IndexError):
  394.             return self.get_single_executor(env, tlist, slist, executor_kw)
  395.         else:
  396.             executor.add_sources(slist)
  397.             return executor
  398.     def _adjustixes(self, files, pre, suf, ensure_suffix=False):
  399.         if not files:
  400.             return []
  401.         result = []
  402.         if not SCons.Util.is_List(files):
  403.             files = [files]
  404.         for f in files:
  405.             if SCons.Util.is_String(f):
  406.                 f = SCons.Util.adjustixes(f, pre, suf, ensure_suffix)
  407.             result.append(f)
  408.         return result
  409.     def _create_nodes(self, env, target = None, source = None):
  410.         """Create and return lists of target and source nodes.
  411.         """
  412.         src_suf = self.get_src_suffix(env)
  413.         target_factory = env.get_factory(self.target_factory)
  414.         source_factory = env.get_factory(self.source_factory)
  415.         source = self._adjustixes(source, None, src_suf)
  416.         slist = env.arg2nodes(source, source_factory)
  417.         pre = self.get_prefix(env, slist)
  418.         suf = self.get_suffix(env, slist)
  419.         if target is None:
  420.             try:
  421.                 t_from_s = slist[0].target_from_source
  422.             except AttributeError:
  423.                 raise UserError("Do not know how to create a target from source `%s'" % slist[0])
  424.             except IndexError:
  425.                 tlist = []
  426.             else:
  427.                 splitext = lambda S,self=self,env=env: self.splitext(S,env)
  428.                 tlist = [ t_from_s(pre, suf, splitext) ]
  429.         else:
  430.             target = self._adjustixes(target, pre, suf, self.ensure_suffix)
  431.             tlist = env.arg2nodes(target, target_factory)
  432.         if self.emitter:
  433.             # The emitter is going to do str(node), but because we're
  434.             # being called *from* a builder invocation, the new targets
  435.             # don't yet have a builder set on them and will look like
  436.             # source files.  Fool the emitter's str() calls by setting
  437.             # up a temporary builder on the new targets.
  438.             new_targets = []
  439.             for t in tlist:
  440.                 if not t.is_derived():
  441.                     t.builder_set(self)
  442.                     new_targets.append(t)
  443.             orig_tlist = tlist[:]
  444.             orig_slist = slist[:]
  445.             target, source = self.emitter(target=tlist, source=slist, env=env)
  446.             # Now delete the temporary builders that we attached to any
  447.             # new targets, so that _node_errors() doesn't do weird stuff
  448.             # to them because it thinks they already have builders.
  449.             for t in new_targets:
  450.                 if t.builder is self:
  451.                     # Only delete the temporary builder if the emitter
  452.                     # didn't change it on us.
  453.                     t.builder_set(None)
  454.             # Have to call arg2nodes yet again, since it is legal for
  455.             # emitters to spit out strings as well as Node instances.
  456.             tlist = env.arg2nodes(target, target_factory,
  457.                                   target=orig_tlist, source=orig_slist)
  458.             slist = env.arg2nodes(source, source_factory,
  459.                                   target=orig_tlist, source=orig_slist)
  460.         return tlist, slist
  461.     def _execute(self, env, target, source, overwarn={}, executor_kw={}):
  462.         # We now assume that target and source are lists or None.
  463.         if self.src_builder:
  464.             source = self.src_builder_sources(env, source, overwarn)
  465.         if self.single_source and len(source) > 1 and target is None:
  466.             result = []
  467.             if target is None: target = [None]*len(source)
  468.             for tgt, src in zip(target, source):
  469.                 if not tgt is None: tgt = [tgt]
  470.                 if not src is None: src = [src]
  471.                 result.extend(self._execute(env, tgt, src, overwarn))
  472.             return SCons.Node.NodeList(result)
  473.         overwarn.warn()
  474.         tlist, slist = self._create_nodes(env, target, source)
  475.         # Check for errors with the specified target/source lists.
  476.         _node_errors(self, env, tlist, slist)
  477.         # The targets are fine, so find or make the appropriate Executor to
  478.         # build this particular list of targets from this particular list of
  479.         # sources.
  480.         if self.multi:
  481.             get_executor = self.get_multi_executor
  482.         else:
  483.             get_executor = self.get_single_executor
  484.         executor = get_executor(env, tlist, slist, executor_kw)
  485.         # Now set up the relevant information in the target Nodes themselves.
  486.         for t in tlist:
  487.             t.cwd = env.fs.getcwd()
  488.             t.builder_set(self)
  489.             t.env_set(env)
  490.             t.add_source(slist)
  491.             t.set_executor(executor)
  492.             t.set_explicit(self.is_explicit)
  493.         return SCons.Node.NodeList(tlist)
  494.     def __call__(self, env, target=None, source=None, chdir=_null, **kw):
  495.         # We now assume that target and source are lists or None.
  496.         # The caller (typically Environment.BuilderWrapper) is
  497.         # responsible for converting any scalar values to lists.
  498.         if chdir is _null:
  499.             ekw = self.executor_kw
  500.         else:
  501.             ekw = self.executor_kw.copy()
  502.             ekw['chdir'] = chdir
  503.         if kw:
  504.             if kw.has_key('srcdir'):
  505.                 def prependDirIfRelative(f, srcdir=kw['srcdir']):
  506.                     import os.path
  507.                     if SCons.Util.is_String(f) and not os.path.isabs(f):
  508.                         f = os.path.join(srcdir, f)
  509.                     return f
  510.                 if not SCons.Util.is_List(source):
  511.                     source = [source]
  512.                 source = map(prependDirIfRelative, source)
  513.                 del kw['srcdir']
  514.             if self.overrides:
  515.                 env_kw = self.overrides.copy()
  516.                 env_kw.update(kw)
  517.             else:
  518.                 env_kw = kw
  519.         else:
  520.             env_kw = self.overrides
  521.         env = env.Override(env_kw)
  522.         return self._execute(env, target, source, OverrideWarner(kw), ekw)
  523.     def adjust_suffix(self, suff):
  524.         if suff and not suff[0] in [ '.', '_', '$' ]:
  525.             return '.' + suff
  526.         return suff
  527.     def get_prefix(self, env, sources=[]):
  528.         prefix = self.prefix
  529.         if callable(prefix):
  530.             prefix = prefix(env, sources)
  531.         return env.subst(prefix)
  532.     def set_suffix(self, suffix):
  533.         if not callable(suffix):
  534.             suffix = self.adjust_suffix(suffix)
  535.         self.suffix = suffix
  536.     def get_suffix(self, env, sources=[]):
  537.         suffix = self.suffix
  538.         if callable(suffix):
  539.             suffix = suffix(env, sources)
  540.         return env.subst(suffix)
  541.     def set_src_suffix(self, src_suffix):
  542.         if not src_suffix:
  543.             src_suffix = []
  544.         elif not SCons.Util.is_List(src_suffix):
  545.             src_suffix = [ src_suffix ]
  546.         adjust = lambda suf, s=self: 
  547.                         callable(suf) and suf or s.adjust_suffix(suf)
  548.         self.src_suffix = map(adjust, src_suffix)
  549.     def get_src_suffix(self, env):
  550.         """Get the first src_suffix in the list of src_suffixes."""
  551.         ret = self.src_suffixes(env)
  552.         if not ret:
  553.             return ''
  554.         return ret[0]
  555.     def add_emitter(self, suffix, emitter):
  556.         """Add a suffix-emitter mapping to this Builder.
  557.         This assumes that emitter has been initialized with an
  558.         appropriate dictionary type, and will throw a TypeError if
  559.         not, so the caller is responsible for knowing that this is an
  560.         appropriate method to call for the Builder in question.
  561.         """
  562.         self.emitter[suffix] = emitter
  563.     def add_src_builder(self, builder):
  564.         """
  565.         Add a new Builder to the list of src_builders.
  566.         This requires wiping out cached values so that the computed
  567.         lists of source suffixes get re-calculated.
  568.         """
  569.         self._memo = {}
  570.         self.src_builder.append(builder)
  571.     def _get_sdict(self, env):
  572.         """
  573.         Returns a dictionary mapping all of the source suffixes of all
  574.         src_builders of this Builder to the underlying Builder that
  575.         should be called first.
  576.         This dictionary is used for each target specified, so we save a
  577.         lot of extra computation by memoizing it for each construction
  578.         environment.
  579.         Note that this is re-computed each time, not cached, because there
  580.         might be changes to one of our source Builders (or one of their
  581.         source Builders, and so on, and so on...) that we can't "see."
  582.         The underlying methods we call cache their computed values,
  583.         though, so we hope repeatedly aggregating them into a dictionary
  584.         like this won't be too big a hit.  We may need to look for a
  585.         better way to do this if performance data show this has turned
  586.         into a significant bottleneck.
  587.         """
  588.         sdict = {}
  589.         for bld in self.get_src_builders(env):
  590.             for suf in bld.src_suffixes(env):
  591.                 sdict[suf] = bld
  592.         return sdict
  593.     def src_builder_sources(self, env, source, overwarn={}):
  594.         sdict = self._get_sdict(env)
  595.         src_suffixes = self.src_suffixes(env)
  596.         lengths = list(set(map(len, src_suffixes)))
  597.         def match_src_suffix(name, src_suffixes=src_suffixes, lengths=lengths):
  598.             node_suffixes = map(lambda l, n=name: n[-l:], lengths)
  599.             for suf in src_suffixes:
  600.                 if suf in node_suffixes:
  601.                     return suf
  602.             return None
  603.         result = []
  604.         for s in SCons.Util.flatten(source):
  605.             if SCons.Util.is_String(s):
  606.                 match_suffix = match_src_suffix(env.subst(s))
  607.                 if not match_suffix and not '.' in s:
  608.                     src_suf = self.get_src_suffix(env)
  609.                     s = self._adjustixes(s, None, src_suf)[0]
  610.             else:
  611.                 match_suffix = match_src_suffix(s.name)
  612.             if match_suffix:
  613.                 try:
  614.                     bld = sdict[match_suffix]
  615.                 except KeyError:
  616.                     result.append(s)
  617.                 else:
  618.                     tlist = bld._execute(env, None, [s], overwarn)
  619.                     # If the subsidiary Builder returned more than one
  620.                     # target, then filter out any sources that this
  621.                     # Builder isn't capable of building.
  622.                     if len(tlist) > 1:
  623.                         mss = lambda t, m=match_src_suffix: m(t.name)
  624.                         tlist = filter(mss, tlist)
  625.                     result.extend(tlist)
  626.             else:
  627.                 result.append(s)
  628.         source_factory = env.get_factory(self.source_factory)
  629.         return env.arg2nodes(result, source_factory)
  630.     def _get_src_builders_key(self, env):
  631.         return id(env)
  632.     memoizer_counters.append(SCons.Memoize.CountDict('get_src_builders', _get_src_builders_key))
  633.     def get_src_builders(self, env):
  634.         """
  635.         Returns the list of source Builders for this Builder.
  636.         This exists mainly to look up Builders referenced as
  637.         strings in the 'BUILDER' variable of the construction
  638.         environment and cache the result.
  639.         """
  640.         memo_key = id(env)
  641.         try:
  642.             memo_dict = self._memo['get_src_builders']
  643.         except KeyError:
  644.             memo_dict = {}
  645.             self._memo['get_src_builders'] = memo_dict
  646.         else:
  647.             try:
  648.                 return memo_dict[memo_key]
  649.             except KeyError:
  650.                 pass
  651.         builders = []
  652.         for bld in self.src_builder:
  653.             if SCons.Util.is_String(bld):
  654.                 try:
  655.                     bld = env['BUILDERS'][bld]
  656.                 except KeyError:
  657.                     continue
  658.             builders.append(bld)
  659.         memo_dict[memo_key] = builders
  660.         return builders
  661.     def _subst_src_suffixes_key(self, env):
  662.         return id(env)
  663.     memoizer_counters.append(SCons.Memoize.CountDict('subst_src_suffixes', _subst_src_suffixes_key))
  664.     def subst_src_suffixes(self, env):
  665.         """
  666.         The suffix list may contain construction variable expansions,
  667.         so we have to evaluate the individual strings.  To avoid doing
  668.         this over and over, we memoize the results for each construction
  669.         environment.
  670.         """
  671.         memo_key = id(env)
  672.         try:
  673.             memo_dict = self._memo['subst_src_suffixes']
  674.         except KeyError:
  675.             memo_dict = {}
  676.             self._memo['subst_src_suffixes'] = memo_dict
  677.         else:
  678.             try:
  679.                 return memo_dict[memo_key]
  680.             except KeyError:
  681.                 pass
  682.         suffixes = map(lambda x, s=self, e=env: e.subst(x), self.src_suffix)
  683.         memo_dict[memo_key] = suffixes
  684.         return suffixes
  685.     def src_suffixes(self, env):
  686.         """
  687.         Returns the list of source suffixes for all src_builders of this
  688.         Builder.
  689.         This is essentially a recursive descent of the src_builder "tree."
  690.         (This value isn't cached because there may be changes in a
  691.         src_builder many levels deep that we can't see.)
  692.         """
  693.         sdict = {}
  694.         suffixes = self.subst_src_suffixes(env)
  695.         for s in suffixes:
  696.             sdict[s] = 1
  697.         for builder in self.get_src_builders(env):
  698.             for s in builder.src_suffixes(env):
  699.                 if not sdict.has_key(s):
  700.                     sdict[s] = 1
  701.                     suffixes.append(s)
  702.         return suffixes
  703. class CompositeBuilder(SCons.Util.Proxy):
  704.     """A Builder Proxy whose main purpose is to always have
  705.     a DictCmdGenerator as its action, and to provide access
  706.     to the DictCmdGenerator's add_action() method.
  707.     """
  708.     def __init__(self, builder, cmdgen):
  709.         if __debug__: logInstanceCreation(self, 'Builder.CompositeBuilder')
  710.         SCons.Util.Proxy.__init__(self, builder)
  711.         # cmdgen should always be an instance of DictCmdGenerator.
  712.         self.cmdgen = cmdgen
  713.         self.builder = builder
  714.     def add_action(self, suffix, action):
  715.         self.cmdgen.add_action(suffix, action)
  716.         self.set_src_suffix(self.cmdgen.src_suffixes())