SCons.Action

1 """SCons.Action 2 3 This encapsulates information about executing any sort of action that 4 can build one or more target Nodes (typically files) from one or more 5 source Nodes (also typically files) given a specific Environment. 6 7 The base class here is ActionBase. The base class supplies just a few 8 OO utility methods and some generic methods for displaying information 9 about an Action in response to the various commands that control printing. 10 11 A second-level base class is _ActionAction. This extends ActionBase 12 by providing the methods that can be used to show and perform an 13 action. True Action objects will subclass _ActionAction; Action 14 factory class objects will subclass ActionBase. 15 16 The heavy lifting is handled by subclasses for the different types of 17 actions we might execute: 18 19 CommandAction 20 CommandGeneratorAction 21 FunctionAction 22 ListAction 23 24 The subclasses supply the following public interface methods used by 25 other modules: 26 27 __call__() 28 THE public interface, "calling" an Action object executes the 29 command or Python function. This also takes care of printing 30 a pre-substitution command for debugging purposes. 31 32 get_contents() 33 Fetches the "contents" of an Action for signature calculation 34 plus the varlist. This is what gets MD5 checksummed to decide 35 if a target needs to be rebuilt because its action changed. 36 37 genstring() 38 Returns a string representation of the Action *without* 39 command substitution, but allows a CommandGeneratorAction to 40 generate the right action based on the specified target, 41 source and env. This is used by the Signature subsystem 42 (through the Executor) to obtain an (imprecise) representation 43 of the Action operation for informative purposes. 44 45 46 Subclasses also supply the following methods for internal use within 47 this module: 48 49 __str__() 50 Returns a string approximation of the Action; no variable 51 substitution is performed. 52 53 execute() 54 The internal method that really, truly, actually handles the 55 execution of a command or Python function. This is used so 56 that the __call__() methods can take care of displaying any 57 pre-substitution representations, and *then* execute an action 58 without worrying about the specific Actions involved. 59 60 get_presig() 61 Fetches the "contents" of a subclass for signature calculation. 62 The varlist is added to this to produce the Action's contents. 63 64 strfunction() 65 Returns a substituted string representation of the Action. 66 This is used by the _ActionAction.show() command to display the 67 command/function that will be executed to generate the target(s). 68 69 There is a related independent ActionCaller class that looks like a 70 regular Action, and which serves as a wrapper for arbitrary functions 71 that we want to let the user specify the arguments to now, but actually 72 execute later (when an out-of-date check determines that it's needed to 73 be executed, for example). Objects of this class are returned by an 74 ActionFactory class that provides a __call__() method as a convenient 75 way for wrapping up the functions. 76 77 """ 78 79 # Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 The SCons Foundation 80 # 81 # Permission is hereby granted, free of charge, to any person obtaining 82 # a copy of this software and associated documentation files (the 83 # "Software"), to deal in the Software without restriction, including 84 # without limitation the rights to use, copy, modify, merge, publish, 85 # distribute, sublicense, and/or sell copies of the Software, and to 86 # permit persons to whom the Software is furnished to do so, subject to 87 # the following conditions: 88 # 89 # The above copyright notice and this permission notice shall be included 90 # in all copies or substantial portions of the Software. 91 # 92 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY 93 # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE 94 # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 95 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 96 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 97 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 98 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 99 100 __revision__ = "src/engine/SCons/Action.py 5023 2010/06/14 22:05:46 scons" 101 102 import SCons.compat 103 104 import dis 105 import os 106 # compat layer imports "cPickle" for us if it's available. 107 import pickle 108 import re 109 import sys 110 import subprocess 111 112 from SCons.Debug import logInstanceCreation 113 import SCons.Errors 114 import SCons.Executor 115 import SCons.Util 116 import SCons.Subst 117 118 # we use these a lot, so try to optimize them 119 is_String = SCons.Util.is_String 120 is_List = SCons.Util.is_List 121

122 -class _null(object):

123 pass

124 125 print_actions = 1 126 execute_actions = 1 127 print_actions_presub = 0 128

129 -def rfile(n):

130 try: 131 return n.rfile() 132 except AttributeError: 133 return n

134

135 -def default_exitstatfunc(s):

136 return s

137 138 try: 139 SET_LINENO = dis.SET_LINENO 140 HAVE_ARGUMENT = dis.HAVE_ARGUMENT 141 except AttributeError: 142 remove_set_lineno_codes = lambda x: x 143 else:

144 - def remove_set_lineno_codes(code):

145 result = [] 146 n = len(code) 147 i = 0 148 while i < n: 149 c = code[i] 150 op = ord(c) 151 if op >= HAVE_ARGUMENT: 152 if op != SET_LINENO: 153 result.append(code[i:i+3]) 154 i = i+3 155 else: 156 result.append(c) 157 i = i+1 158 return ''.join(result)

159 160 strip_quotes = re.compile('^[\'"](.*)[\'"]$') 161 162

163 -def _callable_contents(obj):

164 """Return the signature contents of a callable Python object. 165 """ 166 try: 167 # Test if obj is a method. 168 return _function_contents(obj.im_func) 169 170 except AttributeError: 171 try: 172 # Test if obj is a callable object. 173 return _function_contents(obj.__call__.im_func) 174 175 except AttributeError: 176 try: 177 # Test if obj is a code object. 178 return _code_contents(obj) 179 180 except AttributeError: 181 # Test if obj is a function object. 182 return _function_contents(obj)

183 184

185 -def _object_contents(obj):

186 """Return the signature contents of any Python object. 187 188 We have to handle the case where object contains a code object 189 since it can be pickled directly. 190 """ 191 try: 192 # Test if obj is a method. 193 return _function_contents(obj.im_func) 194 195 except AttributeError: 196 try: 197 # Test if obj is a callable object. 198 return _function_contents(obj.__call__.im_func) 199 200 except AttributeError: 201 try: 202 # Test if obj is a code object. 203 return _code_contents(obj) 204 205 except AttributeError: 206 try: 207 # Test if obj is a function object. 208 return _function_contents(obj) 209 210 except AttributeError: 211 # Should be a pickable Python object. 212 try: 213 return pickle.dumps(obj) 214 except (pickle.PicklingError, TypeError): 215 # This is weird, but it seems that nested classes 216 # are unpickable. The Python docs say it should 217 # always be a PicklingError, but some Python 218 # versions seem to return TypeError. Just do 219 # the best we can. 220 return str(obj)

221 222

223 -def _code_contents(code):

224 """Return the signature contents of a code object. 225 226 By providing direct access to the code object of the 227 function, Python makes this extremely easy. Hooray! 228 229 Unfortunately, older versions of Python include line 230 number indications in the compiled byte code. Boo! 231 So we remove the line number byte codes to prevent 232 recompilations from moving a Python function. 233 """ 234 235 contents = [] 236 237 # The code contents depends on the number of local variables 238 # but not their actual names. 239 contents.append("%s,%s" % (code.co_argcount, len(code.co_varnames))) 240 try: 241 contents.append(",%s,%s" % (len(code.co_cellvars), len(code.co_freevars))) 242 except AttributeError: 243 # Older versions of Python do not support closures. 244 contents.append(",0,0") 245 246 # The code contents depends on any constants accessed by the 247 # function. Note that we have to call _object_contents on each 248 # constants because the code object of nested functions can 249 # show-up among the constants. 250 # 251 # Note that we also always ignore the first entry of co_consts 252 # which contains the function doc string. We assume that the 253 # function does not access its doc string. 254 contents.append(',(' + ','.join(map(_object_contents,code.co_consts[1:])) + ')') 255 256 # The code contents depends on the variable names used to 257 # accessed global variable, as changing the variable name changes 258 # the variable actually accessed and therefore changes the 259 # function result. 260 contents.append(',(' + ','.join(map(_object_contents,code.co_names)) + ')') 261 262 263 # The code contents depends on its actual code!!! 264 contents.append(',(' + str(remove_set_lineno_codes(code.co_code)) + ')') 265 266 return ''.join(contents)

267 268

269 -def _function_contents(func):

270 """Return the signature contents of a function.""" 271 272 contents = [_code_contents(func.func_code)] 273 274 # The function contents depends on the value of defaults arguments 275 if func.func_defaults: 276 contents.append(',(' + ','.join(map(_object_contents,func.func_defaults)) + ')') 277 else: 278 contents.append(',()') 279 280 # The function contents depends on the closure captured cell values. 281 try: 282 closure = func.func_closure or [] 283 except AttributeError: 284 # Older versions of Python do not support closures. 285 closure = [] 286 287 #xxx = [_object_contents(x.cell_contents) for x in closure] 288 try: 289 xxx = [_object_contents(x.cell_contents) for x in closure] 290 except AttributeError: 291 xxx = [] 292 contents.append(',(' + ','.join(xxx) + ')') 293 294 return ''.join(contents)

295 296

297 -def _actionAppend(act1, act2):

298 # This function knows how to slap two actions together. 299 # Mainly, it handles ListActions by concatenating into 300 # a single ListAction. 301 a1 = Action(act1) 302 a2 = Action(act2) 303 if a1 is None or a2 is None: 304 raise TypeError("Cannot append %s to %s" % (type(act1), type(act2))) 305 if isinstance(a1, ListAction): 306 if isinstance(a2, ListAction): 307 return ListAction(a1.list + a2.list) 308 else: 309 return ListAction(a1.list + [ a2 ]) 310 else: 311 if isinstance(a2, ListAction): 312 return ListAction([ a1 ] + a2.list) 313 else: 314 return ListAction([ a1, a2 ])

315

316 -def _do_create_keywords(args, kw):

317 """This converts any arguments after the action argument into 318 their equivalent keywords and adds them to the kw argument. 319 """ 320 v = kw.get('varlist', ()) 321 # prevent varlist="FOO" from being interpreted as ['F', 'O', 'O'] 322 if is_String(v): v = (v,) 323 kw['varlist'] = tuple(v) 324 if args: 325 # turn positional args into equivalent keywords 326 cmdstrfunc = args[0] 327 if cmdstrfunc is None or is_String(cmdstrfunc): 328 kw['cmdstr'] = cmdstrfunc 329 elif callable(cmdstrfunc): 330 kw['strfunction'] = cmdstrfunc 331 else: 332 raise SCons.Errors.UserError( 333 'Invalid command display variable type. ' 334 'You must either pass a string or a callback which ' 335 'accepts (target, source, env) as parameters.') 336 if len(args) > 1: 337 kw['varlist'] = args[1:] + kw['varlist'] 338 if kw.get('strfunction', _null) is not _null \ 339 and kw.get('cmdstr', _null) is not _null: 340 raise SCons.Errors.UserError( 341 'Cannot have both strfunction and cmdstr args to Action()')

342

343 -def _do_create_action(act, kw):

344 """This is the actual "implementation" for the 345 Action factory method, below. This handles the 346 fact that passing lists to Action() itself has 347 different semantics than passing lists as elements 348 of lists. 349 350 The former will create a ListAction, the latter 351 will create a CommandAction by converting the inner 352 list elements to strings.""" 353 354 if isinstance(act, ActionBase): 355 return act 356 357 if is_List(act): 358 return CommandAction(act, **kw) 359 360 if callable(act): 361 try: 362 gen = kw['generator'] 363 del kw['generator'] 364 except KeyError: 365 gen = 0 366 if gen: 367 action_type = CommandGeneratorAction 368 else: 369 action_type = FunctionAction 370 return action_type(act, kw) 371 372 if is_String(act): 373 var=SCons.Util.get_environment_var(act) 374 if var: 375 # This looks like a string that is purely an Environment 376 # variable reference, like "$FOO" or "${FOO}". We do 377 # something special here...we lazily evaluate the contents 378 # of that Environment variable, so a user could put something 379 # like a function or a CommandGenerator in that variable 380 # instead of a string. 381 return LazyAction(var, kw) 382 commands = str(act).split('\n') 383 if len(commands) == 1: 384 return CommandAction(commands[0], **kw) 385 # The list of string commands may include a LazyAction, so we 386 # reprocess them via _do_create_list_action. 387 return _do_create_list_action(commands, kw) 388 return None

389

390 -def _do_create_list_action(act, kw):

391 """A factory for list actions. Convert the input list into Actions 392 and then wrap them in a ListAction.""" 393 acts = [] 394 for a in act: 395 aa = _do_create_action(a, kw) 396 if aa is not None: acts.append(aa) 397 if not acts: 398 return ListAction([]) 399 elif len(acts) == 1: 400 return acts[0] 401 else: 402 return ListAction(acts)

403

404 -def Action(act, *args, **kw):

405 """A factory for action objects.""" 406 # Really simple: the _do_create_* routines do the heavy lifting. 407 _do_create_keywords(args, kw) 408 if is_List(act): 409 return _do_create_list_action(act, kw) 410 return _do_create_action(act, kw)

411

412 -class ActionBase(object):

413 """Base class for all types of action objects that can be held by 414 other objects (Builders, Executors, etc.) This provides the 415 common methods for manipulating and combining those actions.""" 416

417 - def __cmp__(self, other):

418 return cmp(self.__dict__, other)

419

420 - def no_batch_key(self, env, target, source):

421 return None

422 423 batch_key = no_batch_key 424

425 - def genstring(self, target, source, env):

426 return str(self)

427

428 - def get_contents(self, target, source, env):

429 result = [ self.get_presig(target, source, env) ] 430 # This should never happen, as the Action() factory should wrap 431 # the varlist, but just in case an action is created directly, 432 # we duplicate this check here. 433 vl = self.get_varlist(target, source, env) 434 if is_String(vl): vl = (vl,) 435 for v in vl: 436 result.append(env.subst('${'+v+'}')) 437 return ''.join(result)

438

439 - def __add__(self, other):

440 return _actionAppend(self, other)

441

442 - def __radd__(self, other):

443 return _actionAppend(other, self)

444

445 - def presub_lines(self, env):

446 # CommandGeneratorAction needs a real environment 447 # in order to return the proper string here, since 448 # it may call LazyAction, which looks up a key 449 # in that env. So we temporarily remember the env here, 450 # and CommandGeneratorAction will use this env 451 # when it calls its _generate method. 452 self.presub_env = env 453 lines = str(self).split('\n') 454 self.presub_env = None # don't need this any more 455 return lines

456

457 - def get_varlist(self, target, source, env, executor=None):

458 return self.varlist

459

460 - def get_targets(self, env, executor):

461 """ 462 Returns the type of targets ($TARGETS, $CHANGED_TARGETS) used 463 by this action. 464 """ 465 return self.targets

466

467 -class _ActionAction(ActionBase):

468 """Base class for actions that create output objects."""

469 - def __init__(self, cmdstr=_null, strfunction=_null, varlist=(), 470 presub=_null, chdir=None, exitstatfunc=None, 471 batch_key=None, targets='$TARGETS', 472 **kw):

473 self.cmdstr = cmdstr 474 if strfunction is not _null: 475 if strfunction is None: 476 self.cmdstr = None 477 else: 478 self.strfunction = strfunction 479 self.varlist = varlist 480 self.presub = presub 481 self.chdir = chdir 482 if not exitstatfunc: 483 exitstatfunc = default_exitstatfunc 484 self.exitstatfunc = exitstatfunc 485 486 self.targets = targets 487 488 if batch_key: 489 if not callable(batch_key): 490 # They have set batch_key, but not to their own 491 # callable. The default behavior here will batch 492 # *all* targets+sources using this action, separated 493 # for each construction environment. 494 def default_batch_key(self, env, target, source): 495 return (id(self), id(env))

496 batch_key = default_batch_key 497 SCons.Util.AddMethod(self, batch_key, 'batch_key')

498

499 - def print_cmd_line(self, s, target, source, env):

500 sys.stdout.write(s + u"\n")

501

502 - def __call__(self, target, source, env, 503 exitstatfunc=_null, 504 presub=_null, 505 show=_null, 506 execute=_null, 507 chdir=_null, 508 executor=None):

509 if not is_List(target): 510 target = [target] 511 if not is_List(source): 512 source = [source] 513 514 if presub is _null: 515 presub = self.presub 516 if presub is _null: 517 presub = print_actions_presub 518 if exitstatfunc is _null: exitstatfunc = self.exitstatfunc 519 if show is _null: show = print_actions 520 if execute is _null: execute = execute_actions 521 if chdir is _null: chdir = self.chdir 522 save_cwd = None 523 if chdir: 524 save_cwd = os.getcwd() 525 try: 526 chdir = str(chdir.abspath) 527 except AttributeError: 528 if not is_String(chdir): 529 if executor: 530 chdir = str(executor.batches[0].targets[0].dir) 531 else: 532 chdir = str(target[0].dir) 533 if presub: 534 if executor: 535 target = executor.get_all_targets() 536 source = executor.get_all_sources() 537 t = ' and '.join(map(str, target)) 538 l = '\n '.join(self.presub_lines(env)) 539 out = u"Building %s with action:\n %s\n" % (t, l) 540 sys.stdout.write(out) 541 cmd = None 542 if show and self.strfunction: 543 if executor: 544 target = executor.get_all_targets() 545 source = executor.get_all_sources() 546 try: 547 cmd = self.strfunction(target, source, env, executor) 548 except TypeError: 549 cmd = self.strfunction(target, source, env) 550 if cmd: 551 if chdir: 552 cmd = ('os.chdir(%s)\n' % repr(chdir)) + cmd 553 try: 554 get = env.get 555 except AttributeError: 556 print_func = self.print_cmd_line 557 else: 558 print_func = get('PRINT_CMD_LINE_FUNC') 559 if not print_func: 560 print_func = self.print_cmd_line 561 print_func(cmd, target, source, env) 562 stat = 0 563 if execute: 564 if chdir: 565 os.chdir(chdir) 566 try: 567 stat = self.execute(target, source, env, executor=executor) 568 if isinstance(stat, SCons.Errors.BuildError): 569 s = exitstatfunc(stat.status) 570 if s: 571 stat.status = s 572 else: 573 stat = s 574 else: 575 stat = exitstatfunc(stat) 576 finally: 577 if save_cwd: 578 os.chdir(save_cwd) 579 if cmd and save_cwd: 580 print_func('os.chdir(%s)' % repr(save_cwd), target, source, env) 581 582 return stat

583 584

585 -def _string_from_cmd_list(cmd_list):

586 """Takes a list of command line arguments and returns a pretty 587 representation for printing.""" 588 cl = [] 589 for arg in map(str, cmd_list): 590 if ' ' in arg or '\t' in arg: 591 arg = '"' + arg + '"' 592 cl.append(arg) 593 return ' '.join(cl)

594 595 # A fiddlin' little function that has an 'import SCons.Environment' which 596 # can't be moved to the top level without creating an import loop. Since 597 # this import creates a local variable named 'SCons', it blocks access to 598 # the global variable, so we move it here to prevent complaints about local 599 # variables being used uninitialized. 600 default_ENV = None

601 -def get_default_ENV(env):

602 global default_ENV 603 try: 604 return env['ENV'] 605 except KeyError: 606 if not default_ENV: 607 import SCons.Environment 608 # This is a hideously expensive way to get a default shell 609 # environment. What it really should do is run the platform 610 # setup to get the default ENV. Fortunately, it's incredibly 611 # rare for an Environment not to have a shell environment, so 612 # we're not going to worry about it overmuch. 613 default_ENV = SCons.Environment.Environment()['ENV'] 614 return default_ENV

615 616 # This function is still in draft mode. We're going to need something like 617 # it in the long run as more and more places use subprocess, but I'm sure 618 # it'll have to be tweaked to get the full desired functionality. 619 # one special arg (so far?), 'error', to tell what to do with exceptions.

620 -def _subproc(scons_env, cmd, error = 'ignore', **kw):

621 """Do common setup for a subprocess.Popen() call""" 622 # allow std{in,out,err} to be "'devnull'" 623 io = kw.get('stdin') 624 if is_String(io) and io == 'devnull': 625 kw['stdin'] = open(os.devnull) 626 io = kw.get('stdout') 627 if is_String(io) and io == 'devnull': 628 kw['stdout'] = open(os.devnull, 'w') 629 io = kw.get('stderr') 630 if is_String(io) and io == 'devnull': 631 kw['stderr'] = open(os.devnull, 'w') 632 633 # Figure out what shell environment to use 634 ENV = kw.get('env', None) 635 if ENV is None: ENV = get_default_ENV(scons_env) 636 637 # Ensure that the ENV values are all strings: 638 new_env = {} 639 for key, value in ENV.items(): 640 if is_List(value): 641 # If the value is a list, then we assume it is a path list, 642 # because that's a pretty common list-like value to stick 643 # in an environment variable: 644 value = SCons.Util.flatten_sequence(value) 645 new_env[key] = os.pathsep.join(map(str, value)) 646 else: 647 # It's either a string or something else. If it's a string, 648 # we still want to call str() because it might be a *Unicode* 649 # string, which makes subprocess.Popen() gag. If it isn't a 650 # string or a list, then we just coerce it to a string, which 651 # is the proper way to handle Dir and File instances and will 652 # produce something reasonable for just about everything else: 653 new_env[key] = str(value) 654 kw['env'] = new_env 655 656 try: 657 #FUTURE return subprocess.Popen(cmd, **kw) 658 return subprocess.Popen(cmd, **kw) 659 except EnvironmentError, e: 660 if error == 'raise': raise 661 # return a dummy Popen instance that only returns error 662 class dummyPopen(object): 663 def __init__(self, e): self.exception = e 664 def communicate(self): return ('','') 665 def wait(self): return -self.exception.errno 666 stdin = None 667 class f(object): 668 def read(self): return '' 669 def readline(self): return ''

670 stdout = stderr = f() 671 return dummyPopen(e) 672

673 -class CommandAction(_ActionAction):

674 """Class for command-execution actions."""

675 - def __init__(self, cmd, **kw):

676 # Cmd can actually be a list or a single item; if it's a 677 # single item it should be the command string to execute; if a 678 # list then it should be the words of the command string to 679 # execute. Only a single command should be executed by this 680 # object; lists of commands should be handled by embedding 681 # these objects in a ListAction object (which the Action() 682 # factory above does). cmd will be passed to 683 # Environment.subst_list() for substituting environment 684 # variables. 685 if __debug__: logInstanceCreation(self, 'Action.CommandAction') 686 687 _ActionAction.__init__(self, **kw) 688 if is_List(cmd): 689 if list(filter(is_List, cmd)): 690 raise TypeError("CommandAction should be given only " \ 691 "a single command") 692 self.cmd_list = cmd

693

694 - def __str__(self):

695 if is_List(self.cmd_list): 696 return ' '.join(map(str, self.cmd_list)) 697 return str(self.cmd_list)

698

699 - def process(self, target, source, env, executor=None):

700 if executor: 701 result = env.subst_list(self.cmd_list, 0, executor=executor) 702 else: 703 result = env.subst_list(self.cmd_list, 0, target, source) 704 silent = None 705 ignore = None 706 while True: 707 try: c = result[0][0][0] 708 except IndexError: c = None 709 if c == '@': silent = 1 710 elif c == '-': ignore = 1 711 else: break 712 result[0][0] = result[0][0][1:] 713 try: 714 if not result[0][0]: 715 result[0] = result[0][1:] 716 except IndexError: 717 pass 718 return result, ignore, silent

719

720 - def strfunction(self, target, source, env, executor=None):

721 if self.cmdstr is None: 722 return None 723 if self.cmdstr is not _null: 724 from SCons.Subst import SUBST_RAW 725 if executor: 726 c = env.subst(self.cmdstr, SUBST_RAW, executor=executor) 727 else: 728 c = env.subst(self.cmdstr, SUBST_RAW, target, source) 729 if c: 730 return c 731 cmd_list, ignore, silent = self.process(target, source, env, executor) 732 if silent: 733 return '' 734 return _string_from_cmd_list(cmd_list[0])

735

736 - def execute(self, target, source, env, executor=None):

737 """Execute a command action. 738 739 This will handle lists of commands as well as individual commands, 740 because construction variable substitution may turn a single 741 "command" into a list. This means that this class can actually 742 handle lists of commands, even though that's not how we use it 743 externally. 744 """ 745 escape_list = SCons.Subst.escape_list 746 flatten_sequence = SCons.Util.flatten_sequence 747 748 try: 749 shell = env['SHELL'] 750 except KeyError: 751 raise SCons.Errors.UserError('Missing SHELL construction variable.') 752 753 try: 754 spawn = env['SPAWN'] 755 except KeyError: 756 raise SCons.Errors.UserError('Missing SPAWN construction variable.') 757 else: 758 if is_String(spawn): 759 spawn = env.subst(spawn, raw=1, conv=lambda x: x) 760 761 escape = env.get('ESCAPE', lambda x: x) 762 763 ENV = get_default_ENV(env) 764 765 # Ensure that the ENV values are all strings: 766 for key, value in ENV.items(): 767 if not is_String(value): 768 if is_List(value): 769 # If the value is a list, then we assume it is a 770 # path list, because that's a pretty common list-like 771 # value to stick in an environment variable: 772 value = flatten_sequence(value) 773 ENV[key] = os.pathsep.join(map(str, value)) 774 else: 775 # If it isn't a string or a list, then we just coerce 776 # it to a string, which is the proper way to handle 777 # Dir and File instances and will produce something 778 # reasonable for just about everything else: 779 ENV[key] = str(value) 780 781 if executor: 782 target = executor.get_all_targets() 783 source = executor.get_all_sources() 784 cmd_list, ignore, silent = self.process(target, list(map(rfile, source)), env, executor) 785 786 # Use len() to filter out any "command" that's zero-length. 787 for cmd_line in filter(len, cmd_list): 788 # Escape the command line for the interpreter we are using. 789 cmd_line = escape_list(cmd_line, escape) 790 result = spawn(shell, escape, cmd_line[0], cmd_line, ENV) 791 if not ignore and result: 792 msg = "Error %s" % result 793 return SCons.Errors.BuildError(errstr=msg, 794 status=result, 795 action=self, 796 command=cmd_line) 797 return 0

798

799 - def get_presig(self, target, source, env, executor=None):

800 """Return the signature contents of this action's command line. 801 802 This strips $(-$) and everything in between the string, 803 since those parts don't affect signatures. 804 """ 805 from SCons.Subst import SUBST_SIG 806 cmd = self.cmd_list 807 if is_List(cmd): 808 cmd = ' '.join(map(str, cmd)) 809 else: 810 cmd = str(cmd) 811 if executor: 812 return env.subst_target_source(cmd, SUBST_SIG, executor=executor) 813 else: 814 return env.subst_target_source(cmd, SUBST_SIG, target, source)

815

816 - def get_implicit_deps(self, target, source, env, executor=None):

817 icd = env.get('IMPLICIT_COMMAND_DEPENDENCIES', True) 818 if is_String(icd) and icd[:1] == '$': 819 icd = env.subst(icd) 820 if not icd or icd in ('0', 'None'): 821 return [] 822 from SCons.Subst import SUBST_SIG 823 if executor: 824 cmd_list = env.subst_list(self.cmd_list, SUBST_SIG, executor=executor) 825 else: 826 cmd_list = env.subst_list(self.cmd_list, SUBST_SIG, target, source) 827 res = [] 828 for cmd_line in cmd_list: 829 if cmd_line: 830 d = str(cmd_line[0]) 831 m = strip_quotes.match(d) 832 if m: 833 d = m.group(1) 834 d = env.WhereIs(d) 835 if d: 836 res.append(env.fs.File(d)) 837 return res

838

839 -class CommandGeneratorAction(ActionBase):

840 """Class for command-generator actions."""

841 - def __init__(self, generator, kw):

842 if __debug__: logInstanceCreation(self, 'Action.CommandGeneratorAction') 843 self.generator = generator 844 self.gen_kw = kw 845 self.varlist = kw.get('varlist', ()) 846 self.targets = kw.get('targets', '$TARGETS')

847

848 - def _generate(self, target, source, env, for_signature, executor=None):

849 # ensure that target is a list, to make it easier to write 850 # generator functions: 851 if not is_List(target): 852 target = [target] 853 854 if executor: 855 target = executor.get_all_targets() 856 source = executor.get_all_sources() 857 ret = self.generator(target=target, 858 source=source, 859 env=env, 860 for_signature=for_signature) 861 gen_cmd = Action(ret, **self.gen_kw) 862 if not gen_cmd: 863 raise SCons.Errors.UserError("Object returned from command generator: %s cannot be used to create an Action." % repr(ret)) 864 return gen_cmd

865

866 - def __str__(self):

867 try: 868 env = self.presub_env 869 except AttributeError: 870 env = None 871 if env is None: 872 env = SCons.Defaults.DefaultEnvironment() 873 act = self._generate([], [], env, 1) 874 return str(act)

875

876 - def batch_key(self, env, target, source):

877 return self._generate(target, source, env, 1).batch_key(env, target, source)

878

879 - def genstring(self, target, source, env, executor=None):

880 return self._generate(target, source, env, 1, executor).genstring(target, source, env)

881

882 - def __call__(self, target, source, env, exitstatfunc=_null, presub=_null, 883 show=_null, execute=_null, chdir=_null, executor=None):

884 act = self._generate(target, source, env, 0, executor) 885 if act is None: 886 raise UserError("While building `%s': " 887 "Cannot deduce file extension from source files: %s" 888 % (repr(list(map(str, target))), repr(list(map(str, source))))) 889 return act(target, source, env, exitstatfunc, presub, 890 show, execute, chdir, executor)

891

892 - def get_presig(self, target, source, env, executor=None):

893 """Return the signature contents of this action's command line. 894 895 This strips $(-$) and everything in between the string, 896 since those parts don't affect signatures. 897 """ 898 return self._generate(target, source, env, 1, executor).get_presig(target, source, env)

899

900 - def get_implicit_deps(self, target, source, env, executor=None):

901 return self._generate(target, source, env, 1, executor).get_implicit_deps(target, source, env)

902

903 - def get_varlist(self, target, source, env, executor=None):

904 return self._generate(target, source, env, 1, executor).get_varlist(target, source, env, executor)

905

906 - def get_targets(self, env, executor):

907 return self._generate(None, None, env, 1, executor).get_targets(env, executor)

908 909 910 911 # A LazyAction is a kind of hybrid generator and command action for 912 # strings of the form "$VAR". These strings normally expand to other 913 # strings (think "$CCCOM" to "$CC -c -o $TARGET $SOURCE"), but we also 914 # want to be able to replace them with functions in the construction 915 # environment. Consequently, we want lazy evaluation and creation of 916 # an Action in the case of the function, but that's overkill in the more 917 # normal case of expansion to other strings. 918 # 919 # So we do this with a subclass that's both a generator *and* 920 # a command action. The overridden methods all do a quick check 921 # of the construction variable, and if it's a string we just call 922 # the corresponding CommandAction method to do the heavy lifting. 923 # If not, then we call the same-named CommandGeneratorAction method. 924 # The CommandGeneratorAction methods work by using the overridden 925 # _generate() method, that is, our own way of handling "generation" of 926 # an action based on what's in the construction variable. 927

928 -class LazyAction(CommandGeneratorAction, CommandAction):

929

930 - def __init__(self, var, kw):

931 if __debug__: logInstanceCreation(self, 'Action.LazyAction') 932 #FUTURE CommandAction.__init__(self, '${'+var+'}', **kw) 933 CommandAction.__init__(self, '${'+var+'}', **kw) 934 self.var = SCons.Util.to_String(var) 935 self.gen_kw = kw

936

937 - def get_parent_class(self, env):

938 c = env.get(self.var) 939 if is_String(c) and not '\n' in c: 940 return CommandAction 941 return CommandGeneratorAction

942

943 - def _generate_cache(self, env):

944 if env: 945 c = env.get(self.var, '') 946 else: 947 c = '' 948 gen_cmd = Action(c, **self.gen_kw) 949 if not gen_cmd: 950 raise SCons.Errors.UserError("$%s value %s cannot be used to create an Action." % (self.var, repr(c))) 951 return gen_cmd

952

953 - def _generate(self, target, source, env, for_signature, executor=None):

954 return self._generate_cache(env)

955

956 - def __call__(self, target, source, env, *args, **kw):

957 c = self.get_parent_class(env) 958 return c.__call__(self, target, source, env, *args, **kw)

959

960 - def get_presig(self, target, source, env):

961 c = self.get_parent_class(env) 962 return c.get_presig(self, target, source, env)

963

964 - def get_varlist(self, target, source, env, executor=None):

965 c = self.get_parent_class(env) 966 return c.get_varlist(self, target, source, env, executor)

967 968

969 -class FunctionAction(_ActionAction):

970 """Class for Python function actions.""" 971

972 - def __init__(self, execfunction, kw):

973 if __debug__: logInstanceCreation(self, 'Action.FunctionAction') 974 975 self.execfunction = execfunction 976 try: 977 self.funccontents = _callable_contents(execfunction) 978 except AttributeError: 979 try: 980 # See if execfunction will do the heavy lifting for us. 981 self.gc = execfunction.get_contents 982 except AttributeError: 983 # This is weird, just do the best we can. 984 self.funccontents = _object_contents(execfunction) 985 986 _ActionAction.__init__(self, **kw)

987

988 - def function_name(self):

989 try: 990 return self.execfunction.__name__ 991 except AttributeError: 992 try: 993 return self.execfunction.__class__.__name__ 994 except AttributeError: 995 return "unknown_python_function"

996

997 - def strfunction(self, target, source, env, executor=None):

998 if self.cmdstr is None: 999 return None 1000 if self.cmdstr is not _null: 1001 from SCons.Subst import SUBST_RAW 1002 if executor: 1003 c = env.subst(self.cmdstr, SUBST_RAW, executor=executor) 1004 else: 1005 c = env.subst(self.cmdstr, SUBST_RAW, target, source) 1006 if c: 1007 return c 1008 def array(a): 1009 def quote(s): 1010 try: 1011 str_for_display = s.str_for_display 1012 except AttributeError: 1013 s = repr(s) 1014 else: 1015 s = str_for_display() 1016 return s

1017 return '[' + ", ".join(map(quote, a)) + ']'

1018 try: 1019 strfunc = self.execfunction.strfunction 1020 except AttributeError: 1021 pass 1022 else: 1023 if strfunc is None: 1024 return None 1025 if callable(strfunc): 1026 return strfunc(target, source, env) 1027 name = self.function_name() 1028 tstr = array(target) 1029 sstr = array(source) 1030 return "%s(%s, %s)" % (name, tstr, sstr) 1031

1032 - def __str__(self):

1033 name = self.function_name() 1034 if name == 'ActionCaller': 1035 return str(self.execfunction) 1036 return "%s(target, source, env)" % name

1037

1038 - def execute(self, target, source, env, executor=None):

1039 exc_info = (None,None,None) 1040 try: 1041 if executor: 1042 target = executor.get_all_targets() 1043 source = executor.get_all_sources() 1044 rsources = list(map(rfile, source)) 1045 try: 1046 result = self.execfunction(target=target, source=rsources, env=env) 1047 except KeyboardInterrupt, e: 1048 raise 1049 except SystemExit, e: 1050 raise 1051 except Exception, e: 1052 result = e 1053 exc_info = sys.exc_info() 1054 1055 if result: 1056 result = SCons.Errors.convert_to_BuildError(result, exc_info) 1057 result.node=target 1058 result.action=self 1059 try: 1060 result.command=self.strfunction(target, source, env, executor) 1061 except TypeError: 1062 result.command=self.strfunction(target, source, env) 1063 1064 # FIXME: This maintains backward compatibility with respect to 1065 # which type of exceptions were returned by raising an 1066 # exception and which ones were returned by value. It would 1067 # probably be best to always return them by value here, but 1068 # some codes do not check the return value of Actions and I do 1069 # not have the time to modify them at this point. 1070 if (exc_info[1] and 1071 not isinstance(exc_info[1],EnvironmentError)): 1072 raise result 1073 1074 return result 1075 finally: 1076 # Break the cycle between the traceback object and this 1077 # function stack frame. See the sys.exc_info() doc info for 1078 # more information about this issue. 1079 del exc_info

1080 1081

1082 - def get_presig(self, target, source, env):

1083 """Return the signature contents of this callable action.""" 1084 try: 1085 return self.gc(target, source, env) 1086 except AttributeError: 1087 return self.funccontents

1088

1089 - def get_implicit_deps(self, target, source, env):

1090 return []

1091

1092 -class ListAction(ActionBase):

1093 """Class for lists of other actions."""

1094 - def __init__(self, actionlist):

1095 if __debug__: logInstanceCreation(self, 'Action.ListAction') 1096 def list_of_actions(x): 1097 if isinstance(x, ActionBase): 1098 return x 1099 return Action(x)

1100 self.list = list(map(list_of_actions, actionlist)) 1101 # our children will have had any varlist 1102 # applied; we don't need to do it again 1103 self.varlist = () 1104 self.targets = '$TARGETS'

1105

1106 - def genstring(self, target, source, env):

1107 return '\n'.join([a.genstring(target, source, env) for a in self.list])

1108

1109 - def __str__(self):

1110 return '\n'.join(map(str, self.list))

1111

1112 - def presub_lines(self, env):

1113 return SCons.Util.flatten_sequence( 1114 [a.presub_lines(env) for a in self.list])

1115

1116 - def get_presig(self, target, source, env):

1117 """Return the signature contents of this action list. 1118 1119 Simple concatenation of the signatures of the elements. 1120 """ 1121 return "".join([x.get_contents(target, source, env) for x in self.list])

1122

1123 - def __call__(self, target, source, env, exitstatfunc=_null, presub=_null, 1124 show=_null, execute=_null, chdir=_null, executor=None):

1125 if executor: 1126 target = executor.get_all_targets() 1127 source = executor.get_all_sources() 1128 for act in self.list: 1129 stat = act(target, source, env, exitstatfunc, presub, 1130 show, execute, chdir, executor) 1131 if stat: 1132 return stat 1133 return 0

1134

1135 - def get_implicit_deps(self, target, source, env):

1136 result = [] 1137 for act in self.list: 1138 result.extend(act.get_implicit_deps(target, source, env)) 1139 return result

1140

1141 - def get_varlist(self, target, source, env, executor=None):

1142 result = SCons.Util.OrderedDict() 1143 for act in self.list: 1144 for var in act.get_varlist(target, source, env, executor): 1145 result[var] = True 1146 return list(result.keys())

1147

1148 -class ActionCaller(object):

1149 """A class for delaying calling an Action function with specific 1150 (positional and keyword) arguments until the Action is actually 1151 executed. 1152 1153 This class looks to the rest of the world like a normal Action object, 1154 but what it's really doing is hanging on to the arguments until we 1155 have a target, source and env to use for the expansion. 1156 """

1157 - def __init__(self, parent, args, kw):

1158 self.parent = parent 1159 self.args = args 1160 self.kw = kw

1161

1162 - def get_contents(self, target, source, env):

1163 actfunc = self.parent.actfunc 1164 try: 1165 # "self.actfunc" is a function. 1166 contents = str(actfunc.func_code.co_code) 1167 except AttributeError: 1168 # "self.actfunc" is a callable object. 1169 try: 1170 contents = str(actfunc.__call__.im_func.func_code.co_code) 1171 except AttributeError: 1172 # No __call__() method, so it might be a builtin 1173 # or something like that. Do the best we can. 1174 contents = str(actfunc) 1175 contents = remove_set_lineno_codes(contents) 1176 return contents

1177

1178 - def subst(self, s, target, source, env):

1179 # If s is a list, recursively apply subst() 1180 # to every element in the list 1181 if is_List(s): 1182 result = [] 1183 for elem in s: 1184 result.append(self.subst(elem, target, source, env)) 1185 return self.parent.convert(result) 1186 1187 # Special-case hack: Let a custom function wrapped in an 1188 # ActionCaller get at the environment through which the action 1189 # was called by using this hard-coded value as a special return. 1190 if s == '$__env__': 1191 return env 1192 elif is_String(s): 1193 return env.subst(s, 1, target, source) 1194 return self.parent.convert(s)

1195

1196 - def subst_args(self, target, source, env):

1197 return [self.subst(x, target, source, env) for x in self.args]

1198

1199 - def subst_kw(self, target, source, env):

1200 kw = {} 1201 for key in self.kw.keys(): 1202 kw[key] = self.subst(self.kw[key], target, source, env) 1203 return kw

1204

1205 - def __call__(self, target, source, env, executor=None):

1206 args = self.subst_args(target, source, env) 1207 kw = self.subst_kw(target, source, env) 1208 return self.parent.actfunc(*args, **kw)

1209

1210 - def strfunction(self, target, source, env):

1211 args = self.subst_args(target, source, env) 1212 kw = self.subst_kw(target, source, env) 1213 return self.parent.strfunc(*args, **kw)

1214

1215 - def __str__(self):

1216 return self.parent.strfunc(*self.args, **self.kw)

1217

1218 -class ActionFactory(object):

1219 """A factory class that will wrap up an arbitrary function 1220 as an SCons-executable Action object. 1221 1222 The real heavy lifting here is done by the ActionCaller class. 1223 We just collect the (positional and keyword) arguments that we're 1224 called with and give them to the ActionCaller object we create, 1225 so it can hang onto them until it needs them. 1226 """

1227 - def __init__(self, actfunc, strfunc, convert=lambda x: x):

1228 self.actfunc = actfunc 1229 self.strfunc = strfunc 1230 self.convert = convert

1231

1232 - def __call__(self, *args, **kw):

1233 ac = ActionCaller(self, args, kw) 1234 action = Action(ac, strfunction=ac.strfunction) 1235 return action

1236 1237 # Local Variables: 1238 # tab-width:4 1239 # indent-tabs-mode:nil 1240 # End: 1241 # vim: set expandtab tabstop=4 shiftwidth=4: 1242

Source Code for Module SCons.Action