scons/scons-1.2.0/engine/SCons/Executor.py

   1 """SCons.Executor
   2
   3 A module for executing actions with specific lists of target and source
   4 Nodes.
   5
   6 """
   7
   8 #
   9 # Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation
  10 #
  11 # Permission is hereby granted, free of charge, to any person obtaining
  12 # a copy of this software and associated documentation files (the
  13 # "Software"), to deal in the Software without restriction, including
  14 # without limitation the rights to use, copy, modify, merge, publish,
  15 # distribute, sublicense, and/or sell copies of the Software, and to
  16 # permit persons to whom the Software is furnished to do so, subject to
  17 # the following conditions:
  18 #
  19 # The above copyright notice and this permission notice shall be included
  20 # in all copies or substantial portions of the Software.
  21 #
  22 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
  23 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  24 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 #
  30
  31 __revision__ = "src/engine/SCons/Executor.py 3842 2008/12/20 22:59:52 scons"
  32
  33 import string
  34
  35 from SCons.Debug import logInstanceCreation
  36 import SCons.Errors
  37 import SCons.Memoize
  38
  39
  40 class Executor:
  41     """A class for controlling instances of executing an action.
  42
  43     This largely exists to hold a single association of an action,
  44     environment, list of environment override dictionaries, targets
  45     and sources for later processing as needed.
  46     """
  47
  48     if SCons.Memoize.use_memoizer:
  49         __metaclass__ = SCons.Memoize.Memoized_Metaclass
  50
  51     memoizer_counters = []
  52
  53     def __init__(self, action, env=None, overridelist=[{}],
  54                  targets=[], sources=[], builder_kw={}):
  55         if __debug__: logInstanceCreation(self, 'Executor.Executor')
  56         self.set_action_list(action)
  57         self.pre_actions = []
  58         self.post_actions = []
  59         self.env = env
  60         self.overridelist = overridelist
  61         self.targets = targets
  62         self.sources = sources[:]
  63         self.sources_need_sorting = False
  64         self.builder_kw = builder_kw
  65         self._memo = {}
  66
  67     def set_action_list(self, action):
  68         import SCons.Util
  69         if not SCons.Util.is_List(action):
  70             if not action:
  71                 import SCons.Errors
  72                 raise SCons.Errors.UserError, "Executor must have an action."
  73             action = [action]
  74         self.action_list = action
  75
  76     def get_action_list(self):
  77         return self.pre_actions + self.action_list + self.post_actions
  78
  79     memoizer_counters.append(SCons.Memoize.CountValue('get_build_env'))
  80
  81     def get_build_env(self):
  82         """Fetch or create the appropriate build Environment
  83         for this Executor.
  84         """
  85         try:
  86             return self._memo['get_build_env']
  87         except KeyError:
  88             pass
  89
  90         # Create the build environment instance with appropriate
  91         # overrides.  These get evaluated against the current
  92         # environment's construction variables so that users can
  93         # add to existing values by referencing the variable in
  94         # the expansion.
  95         overrides = {}
  96         for odict in self.overridelist:
  97             overrides.update(odict)
  98
  99         import SCons.Defaults
 100         env = self.env or SCons.Defaults.DefaultEnvironment()
 101         build_env = env.Override(overrides)
 102
 103         self._memo['get_build_env'] = build_env
 104
 105         return build_env
 106
 107     def get_build_scanner_path(self, scanner):
 108         """Fetch the scanner path for this executor's targets and sources.
 109         """
 110         env = self.get_build_env()
 111         try:
 112             cwd = self.targets[0].cwd
 113         except (IndexError, AttributeError):
 114             cwd = None
 115         return scanner.path(env, cwd, self.targets, self.get_sources())
 116
 117     def get_kw(self, kw={}):
 118         result = self.builder_kw.copy()
 119         result.update(kw)
 120         return result
 121
 122     def do_nothing(self, target, kw):
 123         return 0
 124
 125     def do_execute(self, target, kw):
 126         """Actually execute the action list."""
 127         env = self.get_build_env()
 128         kw = self.get_kw(kw)
 129         status = 0
 130         for act in self.get_action_list():
 131             status = apply(act, (self.targets, self.get_sources(), env), kw)
 132             if isinstance(status, SCons.Errors.BuildError):
 133                 status.executor = self
 134                 raise status
 135             elif status:
 136                 msg = "Error %s" % status
 137                 raise SCons.Errors.BuildError(
 138                     errstr=msg,
 139                     node=self.targets,
 140                     executor=self,
 141                     action=act)
 142         return status
 143
 144     # use extra indirection because with new-style objects (Python 2.2
 145     # and above) we can't override special methods, and nullify() needs
 146     # to be able to do this.
 147
 148     def __call__(self, target, **kw):
 149         return self.do_execute(target, kw)
 150
 151     def cleanup(self):
 152         self._memo = {}
 153
 154     def add_sources(self, sources):
 155         """Add source files to this Executor's list.  This is necessary
 156         for "multi" Builders that can be called repeatedly to build up
 157         a source file list for a given target."""
 158         self.sources.extend(sources)
 159         self.sources_need_sorting = True
 160
 161     def get_sources(self):
 162         if self.sources_need_sorting:
 163             self.sources = SCons.Util.uniquer_hashables(self.sources)
 164             self.sources_need_sorting = False
 165         return self.sources
 166
 167     def prepare(self):
 168         """
 169         Preparatory checks for whether this Executor can go ahead
 170         and (try to) build its targets.
 171         """
 172         for s in self.get_sources():
 173             if s.missing():
 174                 msg = "Source `%s' not found, needed by target `%s'."
 175                 raise SCons.Errors.StopError, msg % (s, self.targets[0])
 176
 177     def add_pre_action(self, action):
 178         self.pre_actions.append(action)
 179
 180     def add_post_action(self, action):
 181         self.post_actions.append(action)
 182
 183     # another extra indirection for new-style objects and nullify...
 184
 185     def my_str(self):
 186         env = self.get_build_env()
 187         get = lambda action, t=self.targets, s=self.get_sources(), e=env: \
 188                      action.genstring(t, s, e)
 189         return string.join(map(get, self.get_action_list()), "\n")
 190
 191
 192     def __str__(self):
 193         return self.my_str()
 194
 195     def nullify(self):
 196         self.cleanup()
 197         self.do_execute = self.do_nothing
 198         self.my_str     = lambda S=self: ''
 199
 200     memoizer_counters.append(SCons.Memoize.CountValue('get_contents'))
 201
 202     def get_contents(self):
 203         """Fetch the signature contents.  This is the main reason this
 204         class exists, so we can compute this once and cache it regardless
 205         of how many target or source Nodes there are.
 206         """
 207         try:
 208             return self._memo['get_contents']
 209         except KeyError:
 210             pass
 211         env = self.get_build_env()
 212         get = lambda action, t=self.targets, s=self.get_sources(), e=env: \
 213                      action.get_contents(t, s, e)
 214         result = string.join(map(get, self.get_action_list()), "")
 215         self._memo['get_contents'] = result
 216         return result
 217
 218     def get_timestamp(self):
 219         """Fetch a time stamp for this Executor.  We don't have one, of
 220         course (only files do), but this is the interface used by the
 221         timestamp module.
 222         """
 223         return 0
 224
 225     def scan_targets(self, scanner):
 226         self.scan(scanner, self.targets)
 227
 228     def scan_sources(self, scanner):
 229         if self.sources:
 230             self.scan(scanner, self.get_sources())
 231
 232     def scan(self, scanner, node_list):
 233         """Scan a list of this Executor's files (targets or sources) for
 234         implicit dependencies and update all of the targets with them.
 235         This essentially short-circuits an N*M scan of the sources for
 236         each individual target, which is a hell of a lot more efficient.
 237         """
 238         env = self.get_build_env()
 239
 240         deps = []
 241         if scanner:
 242             for node in node_list:
 243                 node.disambiguate()
 244                 s = scanner.select(node)
 245                 if not s:
 246                     continue
 247                 path = self.get_build_scanner_path(s)
 248                 deps.extend(node.get_implicit_deps(env, s, path))
 249         else:
 250             kw = self.get_kw()
 251             for node in node_list:
 252                 node.disambiguate()
 253                 scanner = node.get_env_scanner(env, kw)
 254                 if not scanner:
 255                     continue
 256                 scanner = scanner.select(node)
 257                 if not scanner:
 258                     continue
 259                 path = self.get_build_scanner_path(scanner)
 260                 deps.extend(node.get_implicit_deps(env, scanner, path))
 261
 262         deps.extend(self.get_implicit_deps())
 263
 264         for tgt in self.targets:
 265             tgt.add_to_implicit(deps)
 266
 267     def _get_unignored_sources_key(self, ignore=()):
 268         return tuple(ignore)
 269
 270     memoizer_counters.append(SCons.Memoize.CountDict('get_unignored_sources', _get_unignored_sources_key))
 271
 272     def get_unignored_sources(self, ignore=()):
 273         ignore = tuple(ignore)
 274         try:
 275             memo_dict = self._memo['get_unignored_sources']
 276         except KeyError:
 277             memo_dict = {}
 278             self._memo['get_unignored_sources'] = memo_dict
 279         else:
 280             try:
 281                 return memo_dict[ignore]
 282             except KeyError:
 283                 pass
 284
 285         sourcelist = self.get_sources()
 286         if ignore:
 287             idict = {}
 288             for i in ignore:
 289                 idict[i] = 1
 290             sourcelist = filter(lambda s, i=idict: not i.has_key(s), sourcelist)
 291
 292         memo_dict[ignore] = sourcelist
 293
 294         return sourcelist
 295
 296     def _process_sources_key(self, func, ignore=()):
 297         return (func, tuple(ignore))
 298
 299     memoizer_counters.append(SCons.Memoize.CountDict('process_sources', _process_sources_key))
 300
 301     def process_sources(self, func, ignore=()):
 302         memo_key = (func, tuple(ignore))
 303         try:
 304             memo_dict = self._memo['process_sources']
 305         except KeyError:
 306             memo_dict = {}
 307             self._memo['process_sources'] = memo_dict
 308         else:
 309             try:
 310                 return memo_dict[memo_key]
 311             except KeyError:
 312                 pass
 313
 314         result = map(func, self.get_unignored_sources(ignore))
 315
 316         memo_dict[memo_key] = result
 317
 318         return result
 319
 320     def get_implicit_deps(self):
 321         """Return the executor's implicit dependencies, i.e. the nodes of
 322         the commands to be executed."""
 323         result = []
 324         build_env = self.get_build_env()
 325         for act in self.get_action_list():
 326             result.extend(act.get_implicit_deps(self.targets, self.get_sources(), build_env))
 327         return result
 328
 329 nullenv = None
 330
 331 def get_NullEnvironment():
 332     """Use singleton pattern for Null Environments."""
 333     global nullenv
 334
 335     import SCons.Util
 336     class NullEnvironment(SCons.Util.Null):
 337         import SCons.CacheDir
 338         _CacheDir_path = None
 339         _CacheDir = SCons.CacheDir.CacheDir(None)
 340         def get_CacheDir(self):
 341             return self._CacheDir
 342
 343     if not nullenv:
 344         nullenv = NullEnvironment()
 345     return nullenv
 346
 347 class Null:
 348     """A null Executor, with a null build Environment, that does
 349     nothing when the rest of the methods call it.
 350
 351     This might be able to disapper when we refactor things to
 352     disassociate Builders from Nodes entirely, so we're not
 353     going to worry about unit tests for this--at least for now.
 354     """
 355     def __init__(self, *args, **kw):
 356         if __debug__: logInstanceCreation(self, 'Executor.Null')
 357         self.targets = kw['targets']
 358     def get_build_env(self):
 359         return get_NullEnvironment()
 360     def get_build_scanner_path(self):
 361         return None
 362     def cleanup(self):
 363         pass
 364     def prepare(self):
 365         pass
 366     def get_unignored_sources(self, *args, **kw):
 367         return tuple(())
 368     def get_action_list(self):
 369         return []
 370     def __call__(self, *args, **kw):
 371         return 0
 372     def get_contents(self):
 373         return ''
 374
 375     def _morph(self):
 376         """Morph this Null executor to a real Executor object."""
 377         self.__class__ = Executor
 378         self.__init__([], targets=self.targets)
 379
 380     # The following methods require morphing this Null Executor to a
 381     # real Executor object.
 382
 383     def add_pre_action(self, action):
 384         self._morph()
 385         self.add_pre_action(action)
 386     def add_post_action(self, action):
 387         self._morph()
 388         self.add_post_action(action)
 389     def set_action_list(self, action):
 390         self._morph()
 391         self.set_action_list(action)
 392
 393