Package SCons :: Package Node :: Module FS
[hide private]
[frames] | no frames]

Source Code for Module SCons.Node.FS

   1  """scons.Node.FS 
   2   
   3  File system nodes. 
   4   
   5  These Nodes represent the canonical external objects that people think 
   6  of when they think of building software: files and directories. 
   7   
   8  This holds a "default_fs" variable that should be initialized with an FS 
   9  that can be used by scripts or modules looking for the canonical default. 
  10   
  11  """ 
  12   
  13  # 
  14  # Copyright (c) 2001 - 2015 The SCons Foundation 
  15  # 
  16  # Permission is hereby granted, free of charge, to any person obtaining 
  17  # a copy of this software and associated documentation files (the 
  18  # "Software"), to deal in the Software without restriction, including 
  19  # without limitation the rights to use, copy, modify, merge, publish, 
  20  # distribute, sublicense, and/or sell copies of the Software, and to 
  21  # permit persons to whom the Software is furnished to do so, subject to 
  22  # the following conditions: 
  23  # 
  24  # The above copyright notice and this permission notice shall be included 
  25  # in all copies or substantial portions of the Software. 
  26  # 
  27  # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY 
  28  # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE 
  29  # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
  30  # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 
  31  # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
  32  # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
  33  # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
  34   
  35  __revision__ = "src/engine/SCons/Node/FS.py rel_2.4.1:3453:73fefd3ea0b0 2015/11/09 03:25:05 bdbaddog" 
  36   
  37  import fnmatch 
  38  import os 
  39  import re 
  40  import shutil 
  41  import stat 
  42  import sys 
  43  import time 
  44  import codecs 
  45   
  46  import SCons.Action 
  47  import SCons.Debug 
  48  from SCons.Debug import logInstanceCreation 
  49  import SCons.Errors 
  50  import SCons.Memoize 
  51  import SCons.Node 
  52  import SCons.Node.Alias 
  53  import SCons.Subst 
  54  import SCons.Util 
  55  import SCons.Warnings 
  56   
  57  from SCons.Debug import Trace 
  58   
  59  print_duplicate = 0 
60 61 62 -def sconsign_none(node):
63 raise NotImplementedError
64
65 -def sconsign_dir(node):
66 """Return the .sconsign file info for this directory, 67 creating it first if necessary.""" 68 if not node._sconsign: 69 import SCons.SConsign 70 node._sconsign = SCons.SConsign.ForDirectory(node) 71 return node._sconsign
72 73 _sconsign_map = {0 : sconsign_none, 74 1 : sconsign_dir}
75 76 -class EntryProxyAttributeError(AttributeError):
77 """ 78 An AttributeError subclass for recording and displaying the name 79 of the underlying Entry involved in an AttributeError exception. 80 """
81 - def __init__(self, entry_proxy, attribute):
82 AttributeError.__init__(self) 83 self.entry_proxy = entry_proxy 84 self.attribute = attribute
85 - def __str__(self):
86 entry = self.entry_proxy.get() 87 fmt = "%s instance %s has no attribute %s" 88 return fmt % (entry.__class__.__name__, 89 repr(entry.name), 90 repr(self.attribute))
91 92 # The max_drift value: by default, use a cached signature value for 93 # any file that's been untouched for more than two days. 94 default_max_drift = 2*24*60*60 95 96 # 97 # We stringify these file system Nodes a lot. Turning a file system Node 98 # into a string is non-trivial, because the final string representation 99 # can depend on a lot of factors: whether it's a derived target or not, 100 # whether it's linked to a repository or source directory, and whether 101 # there's duplication going on. The normal technique for optimizing 102 # calculations like this is to memoize (cache) the string value, so you 103 # only have to do the calculation once. 104 # 105 # A number of the above factors, however, can be set after we've already 106 # been asked to return a string for a Node, because a Repository() or 107 # VariantDir() call or the like may not occur until later in SConscript 108 # files. So this variable controls whether we bother trying to save 109 # string values for Nodes. The wrapper interface can set this whenever 110 # they're done mucking with Repository and VariantDir and the other stuff, 111 # to let this module know it can start returning saved string values 112 # for Nodes. 113 # 114 Save_Strings = None
115 116 -def save_strings(val):
117 global Save_Strings 118 Save_Strings = val
119 120 # 121 # Avoid unnecessary function calls by recording a Boolean value that 122 # tells us whether or not os.path.splitdrive() actually does anything 123 # on this system, and therefore whether we need to bother calling it 124 # when looking up path names in various methods below. 125 # 126 127 do_splitdrive = None 128 _my_splitdrive =None
129 130 -def initialize_do_splitdrive():
131 global do_splitdrive 132 global has_unc 133 drive, path = os.path.splitdrive('X:/foo') 134 has_unc = hasattr(os.path, 'splitunc') 135 136 do_splitdrive = not not drive or has_unc 137 138 global _my_splitdrive 139 if has_unc: 140 def splitdrive(p): 141 if p[1:2] == ':': 142 return p[:2], p[2:] 143 if p[0:2] == '//': 144 # Note that we leave a leading slash in the path 145 # because UNC paths are always absolute. 146 return '//', p[1:] 147 return '', p
148 else: 149 def splitdrive(p): 150 if p[1:2] == ':': 151 return p[:2], p[2:] 152 return '', p 153 _my_splitdrive = splitdrive 154 155 # Keep some commonly used values in global variables to skip to 156 # module look-up costs. 157 global OS_SEP 158 global UNC_PREFIX 159 global os_sep_is_slash 160 161 OS_SEP = os.sep 162 UNC_PREFIX = OS_SEP + OS_SEP 163 os_sep_is_slash = OS_SEP == '/' 164 165 initialize_do_splitdrive() 166 167 # Used to avoid invoking os.path.normpath if not necessary. 168 needs_normpath_check = re.compile( 169 r''' 170 # We need to renormalize the path if it contains any consecutive 171 # '/' characters. 172 .*// | 173 174 # We need to renormalize the path if it contains a '..' directory. 175 # Note that we check for all the following cases: 176 # 177 # a) The path is a single '..' 178 # b) The path starts with '..'. E.g. '../' or '../moredirs' 179 # but we not match '..abc/'. 180 # c) The path ends with '..'. E.g. '/..' or 'dirs/..' 181 # d) The path contains a '..' in the middle. 182 # E.g. dirs/../moredirs 183 184 (.*/)?\.\.(?:/|$) | 185 186 # We need to renormalize the path if it contains a '.' 187 # directory, but NOT if it is a single '.' '/' characters. We 188 # do not want to match a single '.' because this case is checked 189 # for explicitely since this is common enough case. 190 # 191 # Note that we check for all the following cases: 192 # 193 # a) We don't match a single '.' 194 # b) We match if the path starts with '.'. E.g. './' or 195 # './moredirs' but we not match '.abc/'. 196 # c) We match if the path ends with '.'. E.g. '/.' or 197 # 'dirs/.' 198 # d) We match if the path contains a '.' in the middle. 199 # E.g. dirs/./moredirs 200 201 \./|.*/\.(?:/|$) 202 203 ''', 204 re.VERBOSE 205 ) 206 needs_normpath_match = needs_normpath_check.match 207 208 # 209 # SCons.Action objects for interacting with the outside world. 210 # 211 # The Node.FS methods in this module should use these actions to 212 # create and/or remove files and directories; they should *not* use 213 # os.{link,symlink,unlink,mkdir}(), etc., directly. 214 # 215 # Using these SCons.Action objects ensures that descriptions of these 216 # external activities are properly displayed, that the displays are 217 # suppressed when the -s (silent) option is used, and (most importantly) 218 # the actions are disabled when the the -n option is used, in which case 219 # there should be *no* changes to the external file system(s)... 220 # 221 222 if hasattr(os, 'link'): 235 else: 236 _hardlink_func = None 237 238 if hasattr(os, 'symlink'): 241 else: 242 _softlink_func = None
243 244 -def _copy_func(fs, src, dest):
245 shutil.copy2(src, dest) 246 st = fs.stat(src) 247 fs.chmod(dest, stat.S_IMODE(st[stat.ST_MODE]) | stat.S_IWRITE)
248 249 250 Valid_Duplicates = ['hard-soft-copy', 'soft-hard-copy', 251 'hard-copy', 'soft-copy', 'copy'] 252 253 Link_Funcs = [] # contains the callables of the specified duplication style
254 255 -def set_duplicate(duplicate):
256 # Fill in the Link_Funcs list according to the argument 257 # (discarding those not available on the platform). 258 259 # Set up the dictionary that maps the argument names to the 260 # underlying implementations. We do this inside this function, 261 # not in the top-level module code, so that we can remap os.link 262 # and os.symlink for testing purposes. 263 link_dict = { 264 'hard' : _hardlink_func, 265 'soft' : _softlink_func, 266 'copy' : _copy_func 267 } 268 269 if not duplicate in Valid_Duplicates: 270 raise SCons.Errors.InternalError("The argument of set_duplicate " 271 "should be in Valid_Duplicates") 272 global Link_Funcs 273 Link_Funcs = [] 274 for func in duplicate.split('-'): 275 if link_dict[func]: 276 Link_Funcs.append(link_dict[func])
277
278 -def LinkFunc(target, source, env):
279 # Relative paths cause problems with symbolic links, so 280 # we use absolute paths, which may be a problem for people 281 # who want to move their soft-linked src-trees around. Those 282 # people should use the 'hard-copy' mode, softlinks cannot be 283 # used for that; at least I have no idea how ... 284 src = source[0].get_abspath() 285 dest = target[0].get_abspath() 286 dir, file = os.path.split(dest) 287 if dir and not target[0].fs.isdir(dir): 288 os.makedirs(dir) 289 if not Link_Funcs: 290 # Set a default order of link functions. 291 set_duplicate('hard-soft-copy') 292 fs = source[0].fs 293 # Now link the files with the previously specified order. 294 for func in Link_Funcs: 295 try: 296 func(fs, src, dest) 297 break 298 except (IOError, OSError): 299 # An OSError indicates something happened like a permissions 300 # problem or an attempt to symlink across file-system 301 # boundaries. An IOError indicates something like the file 302 # not existing. In either case, keeping trying additional 303 # functions in the list and only raise an error if the last 304 # one failed. 305 if func == Link_Funcs[-1]: 306 # exception of the last link method (copy) are fatal 307 raise 308 return 0
309 310 Link = SCons.Action.Action(LinkFunc, None)
311 -def LocalString(target, source, env):
312 return 'Local copy of %s from %s' % (target[0], source[0])
313 314 LocalCopy = SCons.Action.Action(LinkFunc, LocalString)
315 316 -def UnlinkFunc(target, source, env):
317 t = target[0] 318 t.fs.unlink(t.get_abspath()) 319 return 0
320 321 Unlink = SCons.Action.Action(UnlinkFunc, None)
322 323 -def MkdirFunc(target, source, env):
324 t = target[0] 325 if not t.exists(): 326 t.fs.mkdir(t.get_abspath()) 327 return 0
328 329 Mkdir = SCons.Action.Action(MkdirFunc, None, presub=None) 330 331 MkdirBuilder = None
332 333 -def get_MkdirBuilder():
334 global MkdirBuilder 335 if MkdirBuilder is None: 336 import SCons.Builder 337 import SCons.Defaults 338 # "env" will get filled in by Executor.get_build_env() 339 # calling SCons.Defaults.DefaultEnvironment() when necessary. 340 MkdirBuilder = SCons.Builder.Builder(action = Mkdir, 341 env = None, 342 explain = None, 343 is_explicit = None, 344 target_scanner = SCons.Defaults.DirEntryScanner, 345 name = "MkdirBuilder") 346 return MkdirBuilder
347
348 -class _Null(object):
349 pass
350 351 _null = _Null() 352 353 DefaultSCCSBuilder = None 354 DefaultRCSBuilder = None
355 356 -def get_DefaultSCCSBuilder():
357 global DefaultSCCSBuilder 358 if DefaultSCCSBuilder is None: 359 import SCons.Builder 360 # "env" will get filled in by Executor.get_build_env() 361 # calling SCons.Defaults.DefaultEnvironment() when necessary. 362 act = SCons.Action.Action('$SCCSCOM', '$SCCSCOMSTR') 363 DefaultSCCSBuilder = SCons.Builder.Builder(action = act, 364 env = None, 365 name = "DefaultSCCSBuilder") 366 return DefaultSCCSBuilder
367
368 -def get_DefaultRCSBuilder():
369 global DefaultRCSBuilder 370 if DefaultRCSBuilder is None: 371 import SCons.Builder 372 # "env" will get filled in by Executor.get_build_env() 373 # calling SCons.Defaults.DefaultEnvironment() when necessary. 374 act = SCons.Action.Action('$RCS_COCOM', '$RCS_COCOMSTR') 375 DefaultRCSBuilder = SCons.Builder.Builder(action = act, 376 env = None, 377 name = "DefaultRCSBuilder") 378 return DefaultRCSBuilder
379 380 # Cygwin's os.path.normcase pretends it's on a case-sensitive filesystem. 381 _is_cygwin = sys.platform == "cygwin" 382 if os.path.normcase("TeSt") == os.path.normpath("TeSt") and not _is_cygwin:
383 - def _my_normcase(x):
384 return x
385 else:
386 - def _my_normcase(x):
387 return x.upper()
388
389 390 391 -class DiskChecker(object):
392 - def __init__(self, type, do, ignore):
393 self.type = type 394 self.do = do 395 self.ignore = ignore 396 self.func = do
397 - def __call__(self, *args, **kw):
398 return self.func(*args, **kw)
399 - def set(self, list):
400 if self.type in list: 401 self.func = self.do 402 else: 403 self.func = self.ignore
404
405 -def do_diskcheck_match(node, predicate, errorfmt):
406 result = predicate() 407 try: 408 # If calling the predicate() cached a None value from stat(), 409 # remove it so it doesn't interfere with later attempts to 410 # build this Node as we walk the DAG. (This isn't a great way 411 # to do this, we're reaching into an interface that doesn't 412 # really belong to us, but it's all about performance, so 413 # for now we'll just document the dependency...) 414 if node._memo['stat'] is None: 415 del node._memo['stat'] 416 except (AttributeError, KeyError): 417 pass 418 if result: 419 raise TypeError(errorfmt % node.get_abspath())
420
421 -def ignore_diskcheck_match(node, predicate, errorfmt):
422 pass
423
424 -def do_diskcheck_rcs(node, name):
425 try: 426 rcs_dir = node.rcs_dir 427 except AttributeError: 428 if node.entry_exists_on_disk('RCS'): 429 rcs_dir = node.Dir('RCS') 430 else: 431 rcs_dir = None 432 node.rcs_dir = rcs_dir 433 if rcs_dir: 434 return rcs_dir.entry_exists_on_disk(name+',v') 435 return None
436
437 -def ignore_diskcheck_rcs(node, name):
438 return None
439
440 -def do_diskcheck_sccs(node, name):
441 try: 442 sccs_dir = node.sccs_dir 443 except AttributeError: 444 if node.entry_exists_on_disk('SCCS'): 445 sccs_dir = node.Dir('SCCS') 446 else: 447 sccs_dir = None 448 node.sccs_dir = sccs_dir 449 if sccs_dir: 450 return sccs_dir.entry_exists_on_disk('s.'+name) 451 return None
452
453 -def ignore_diskcheck_sccs(node, name):
454 return None
455 456 diskcheck_match = DiskChecker('match', do_diskcheck_match, ignore_diskcheck_match) 457 diskcheck_rcs = DiskChecker('rcs', do_diskcheck_rcs, ignore_diskcheck_rcs) 458 diskcheck_sccs = DiskChecker('sccs', do_diskcheck_sccs, ignore_diskcheck_sccs) 459 460 diskcheckers = [ 461 diskcheck_match, 462 diskcheck_rcs, 463 diskcheck_sccs, 464 ]
465 466 -def set_diskcheck(list):
467 for dc in diskcheckers: 468 dc.set(list)
469
470 -def diskcheck_types():
471 return [dc.type for dc in diskcheckers]
472
473 474 475 -class EntryProxy(SCons.Util.Proxy):
476 477 __str__ = SCons.Util.Delegate('__str__') 478
479 - def __get_abspath(self):
480 entry = self.get() 481 return SCons.Subst.SpecialAttrWrapper(entry.get_abspath(), 482 entry.name + "_abspath")
483
484 - def __get_filebase(self):
485 name = self.get().name 486 return SCons.Subst.SpecialAttrWrapper(SCons.Util.splitext(name)[0], 487 name + "_filebase")
488
489 - def __get_suffix(self):
490 name = self.get().name 491 return SCons.Subst.SpecialAttrWrapper(SCons.Util.splitext(name)[1], 492 name + "_suffix")
493
494 - def __get_file(self):
495 name = self.get().name 496 return SCons.Subst.SpecialAttrWrapper(name, name + "_file")
497
498 - def __get_base_path(self):
499 """Return the file's directory and file name, with the 500 suffix stripped.""" 501 entry = self.get() 502 return SCons.Subst.SpecialAttrWrapper(SCons.Util.splitext(entry.get_path())[0], 503 entry.name + "_base")
504
505 - def __get_posix_path(self):
506 """Return the path with / as the path separator, 507 regardless of platform.""" 508 if os_sep_is_slash: 509 return self 510 else: 511 entry = self.get() 512 r = entry.get_path().replace(OS_SEP, '/') 513 return SCons.Subst.SpecialAttrWrapper(r, entry.name + "_posix")
514
515 - def __get_windows_path(self):
516 """Return the path with \ as the path separator, 517 regardless of platform.""" 518 if OS_SEP == '\\': 519 return self 520 else: 521 entry = self.get() 522 r = entry.get_path().replace(OS_SEP, '\\') 523 return SCons.Subst.SpecialAttrWrapper(r, entry.name + "_windows")
524
525 - def __get_srcnode(self):
526 return EntryProxy(self.get().srcnode())
527
528 - def __get_srcdir(self):
529 """Returns the directory containing the source node linked to this 530 node via VariantDir(), or the directory of this node if not linked.""" 531 return EntryProxy(self.get().srcnode().dir)
532
533 - def __get_rsrcnode(self):
534 return EntryProxy(self.get().srcnode().rfile())
535
536 - def __get_rsrcdir(self):
537 """Returns the directory containing the source node linked to this 538 node via VariantDir(), or the directory of this node if not linked.""" 539 return EntryProxy(self.get().srcnode().rfile().dir)
540
541 - def __get_dir(self):
542 return EntryProxy(self.get().dir)
543 544 dictSpecialAttrs = { "base" : __get_base_path, 545 "posix" : __get_posix_path, 546 "windows" : __get_windows_path, 547 "win32" : __get_windows_path, 548 "srcpath" : __get_srcnode, 549 "srcdir" : __get_srcdir, 550 "dir" : __get_dir, 551 "abspath" : __get_abspath, 552 "filebase" : __get_filebase, 553 "suffix" : __get_suffix, 554 "file" : __get_file, 555 "rsrcpath" : __get_rsrcnode, 556 "rsrcdir" : __get_rsrcdir, 557 } 558
559 - def __getattr__(self, name):
560 # This is how we implement the "special" attributes 561 # such as base, posix, srcdir, etc. 562 try: 563 attr_function = self.dictSpecialAttrs[name] 564 except KeyError: 565 try: 566 attr = SCons.Util.Proxy.__getattr__(self, name) 567 except AttributeError, e: 568 # Raise our own AttributeError subclass with an 569 # overridden __str__() method that identifies the 570 # name of the entry that caused the exception. 571 raise EntryProxyAttributeError(self, name) 572 return attr 573 else: 574 return attr_function(self)
575
576 -class Base(SCons.Node.Node):
577 """A generic class for file system entries. This class is for 578 when we don't know yet whether the entry being looked up is a file 579 or a directory. Instances of this class can morph into either 580 Dir or File objects by a later, more precise lookup. 581 582 Note: this class does not define __cmp__ and __hash__ for 583 efficiency reasons. SCons does a lot of comparing of 584 Node.FS.{Base,Entry,File,Dir} objects, so those operations must be 585 as fast as possible, which means we want to use Python's built-in 586 object identity comparisons. 587 """ 588 589 __slots__ = ['name', 590 'fs', 591 '_abspath', 592 '_labspath', 593 '_path', 594 '_tpath', 595 '_path_elements', 596 'dir', 597 'cwd', 598 'duplicate', 599 '_local', 600 'sbuilder', 601 '_proxy', 602 '_func_sconsign'] 603
604 - def __init__(self, name, directory, fs):
605 """Initialize a generic Node.FS.Base object. 606 607 Call the superclass initialization, take care of setting up 608 our relative and absolute paths, identify our parent 609 directory, and indicate that this node should use 610 signatures.""" 611 if SCons.Debug.track_instances: logInstanceCreation(self, 'Node.FS.Base') 612 SCons.Node.Node.__init__(self) 613 614 # Filenames and paths are probably reused and are intern'ed to 615 # save some memory. 616 617 #: Filename with extension as it was specified when the object was 618 #: created; to obtain filesystem path, use Python str() function 619 self.name = SCons.Util.silent_intern(name) 620 self.fs = fs #: Reference to parent Node.FS object 621 622 assert directory, "A directory must be provided" 623 624 self._abspath = None 625 self._labspath = None 626 self._path = None 627 self._tpath = None 628 self._path_elements = None 629 630 self.dir = directory 631 self.cwd = None # will hold the SConscript directory for target nodes 632 self.duplicate = directory.duplicate 633 self.changed_since_last_build = 2 634 self._func_sconsign = 0 635 self._func_exists = 2 636 self._func_rexists = 2 637 self._func_get_contents = 0 638 self._func_target_from_source = 1 639 self.store_info = 1
640
641 - def str_for_display(self):
642 return '"' + self.__str__() + '"'
643
644 - def must_be_same(self, klass):
645 """ 646 This node, which already existed, is being looked up as the 647 specified klass. Raise an exception if it isn't. 648 """ 649 if isinstance(self, klass) or klass is Entry: 650 return 651 raise TypeError("Tried to lookup %s '%s' as a %s." %\ 652 (self.__class__.__name__, self.get_internal_path(), klass.__name__))
653
654 - def get_dir(self):
655 return self.dir
656
657 - def get_suffix(self):
658 return SCons.Util.splitext(self.name)[1]
659
660 - def rfile(self):
661 return self
662
663 - def __getattr__(self, attr):
664 """ Together with the node_bwcomp dict defined below, 665 this method provides a simple backward compatibility 666 layer for the Node attributes 'abspath', 'labspath', 667 'path', 'tpath', 'suffix' and 'path_elements'. These Node 668 attributes used to be directly available in v2.3 and earlier, but 669 have been replaced by getter methods that initialize the 670 single variables lazily when required, in order to save memory. 671 The redirection to the getters lets older Tools and 672 SConstruct continue to work without any additional changes, 673 fully transparent to the user. 674 Note, that __getattr__ is only called as fallback when the 675 requested attribute can't be found, so there should be no 676 speed performance penalty involved for standard builds. 677 """ 678 if attr in node_bwcomp: 679 return node_bwcomp[attr](self) 680 681 raise AttributeError("%r object has no attribute %r" % 682 (self.__class__, attr))
683
684 - def __str__(self):
685 """A Node.FS.Base object's string representation is its path 686 name.""" 687 global Save_Strings 688 if Save_Strings: 689 return self._save_str() 690 return self._get_str()
691 692 @SCons.Memoize.CountMethodCall
693 - def _save_str(self):
694 try: 695 return self._memo['_save_str'] 696 except KeyError: 697 pass 698 result = sys.intern(self._get_str()) 699 self._memo['_save_str'] = result 700 return result
701
702 - def _get_str(self):
703 global Save_Strings 704 if self.duplicate or self.is_derived(): 705 return self.get_path() 706 srcnode = self.srcnode() 707 if srcnode.stat() is None and self.stat() is not None: 708 result = self.get_path() 709 else: 710 result = srcnode.get_path() 711 if not Save_Strings: 712 # We're not at the point where we're saving the string 713 # representations of FS Nodes (because we haven't finished 714 # reading the SConscript files and need to have str() return 715 # things relative to them). That also means we can't yet 716 # cache values returned (or not returned) by stat(), since 717 # Python code in the SConscript files might still create 718 # or otherwise affect the on-disk file. So get rid of the 719 # values that the underlying stat() method saved. 720 try: del self._memo['stat'] 721 except KeyError: pass 722 if self is not srcnode: 723 try: del srcnode._memo['stat'] 724 except KeyError: pass 725 return result
726 727 rstr = __str__ 728 729 @SCons.Memoize.CountMethodCall
730 - def stat(self):
731 try: return self._memo['stat'] 732 except KeyError: pass 733 try: result = self.fs.stat(self.get_abspath()) 734 except os.error: result = None 735 self._memo['stat'] = result 736 return result
737
738 - def exists(self):
739 return SCons.Node._exists_map[self._func_exists](self)
740
741 - def rexists(self):
742 return SCons.Node._rexists_map[self._func_rexists](self)
743
744 - def getmtime(self):
745 st = self.stat() 746 if st: return st[stat.ST_MTIME] 747 else: return None
748
749 - def getsize(self):
750 st = self.stat() 751 if st: return st[stat.ST_SIZE] 752 else: return None
753
754 - def isdir(self):
755 st = self.stat() 756 return st is not None and stat.S_ISDIR(st[stat.ST_MODE])
757
758 - def isfile(self):
759 st = self.stat() 760 return st is not None and stat.S_ISREG(st[stat.ST_MODE])
761 762 if hasattr(os, 'symlink'): 767 else: 770
771 - def is_under(self, dir):
772 if self is dir: 773 return 1 774 else: 775 return self.dir.is_under(dir)
776
777 - def set_local(self):
778 self._local = 1
779
780 - def srcnode(self):
781 """If this node is in a build path, return the node 782 corresponding to its source file. Otherwise, return 783 ourself. 784 """ 785 srcdir_list = self.dir.srcdir_list() 786 if srcdir_list: 787 srcnode = srcdir_list[0].Entry(self.name) 788 srcnode.must_be_same(self.__class__) 789 return srcnode 790 return self
791
792 - def get_path(self, dir=None):
793 """Return path relative to the current working directory of the 794 Node.FS.Base object that owns us.""" 795 if not dir: 796 dir = self.fs.getcwd() 797 if self == dir: 798 return '.' 799 path_elems = self.get_path_elements() 800 pathname = '' 801 try: i = path_elems.index(dir) 802 except ValueError: 803 for p in path_elems[:-1]: 804 pathname += p.dirname 805 else: 806 for p in path_elems[i+1:-1]: 807 pathname += p.dirname 808 return pathname + path_elems[-1].name
809
810 - def set_src_builder(self, builder):
811 """Set the source code builder for this node.""" 812 self.sbuilder = builder 813 if not self.has_builder(): 814 self.builder_set(builder)
815
816 - def src_builder(self):
817 """Fetch the source code builder for this node. 818 819 If there isn't one, we cache the source code builder specified 820 for the directory (which in turn will cache the value from its 821 parent directory, and so on up to the file system root). 822 """ 823 try: 824 scb = self.sbuilder 825 except AttributeError: 826 scb = self.dir.src_builder() 827 self.sbuilder = scb 828 return scb
829
830 - def get_abspath(self):
831 """Get the absolute path of the file.""" 832 return self.dir.entry_abspath(self.name)
833
834 - def get_labspath(self):
835 """Get the absolute path of the file.""" 836 return self.dir.entry_labspath(self.name)
837
838 - def get_internal_path(self):
839 if self.dir._path == '.': 840 return self.name 841 else: 842 return self.dir.entry_path(self.name)
843
844 - def get_tpath(self):
845 if self.dir._tpath == '.': 846 return self.name 847 else: 848 return self.dir.entry_tpath(self.name)
849
850 - def get_path_elements(self):
851 return self.dir._path_elements + [self]
852
853 - def for_signature(self):
854 # Return just our name. Even an absolute path would not work, 855 # because that can change thanks to symlinks or remapped network 856 # paths. 857 return self.name
858
859 - def get_subst_proxy(self):
860 try: 861 return self._proxy 862 except AttributeError: 863 ret = EntryProxy(self) 864 self._proxy = ret 865 return ret
866
867 - def target_from_source(self, prefix, suffix, splitext=SCons.Util.splitext):
868 """ 869 870 Generates a target entry that corresponds to this entry (usually 871 a source file) with the specified prefix and suffix. 872 873 Note that this method can be overridden dynamically for generated 874 files that need different behavior. See Tool/swig.py for 875 an example. 876 """ 877 return SCons.Node._target_from_source_map[self._func_target_from_source](self, prefix, suffix, splitext)
878
879 - def _Rfindalldirs_key(self, pathlist):
880 return pathlist
881 882 @SCons.Memoize.CountDictCall(_Rfindalldirs_key)
883 - def Rfindalldirs(self, pathlist):
884 """ 885 Return all of the directories for a given path list, including 886 corresponding "backing" directories in any repositories. 887 888 The Node lookups are relative to this Node (typically a 889 directory), so memoizing result saves cycles from looking 890 up the same path for each target in a given directory. 891 """ 892 try: 893 memo_dict = self._memo['Rfindalldirs'] 894 except KeyError: 895 memo_dict = {} 896 self._memo['Rfindalldirs'] = memo_dict 897 else: 898 try: 899 return memo_dict[pathlist] 900 except KeyError: 901 pass 902 903 create_dir_relative_to_self = self.Dir 904 result = [] 905 for path in pathlist: 906 if isinstance(path, SCons.Node.Node): 907 result.append(path) 908 else: 909 dir = create_dir_relative_to_self(path) 910 result.extend(dir.get_all_rdirs()) 911 912 memo_dict[pathlist] = result 913 914 return result
915
916 - def RDirs(self, pathlist):
917 """Search for a list of directories in the Repository list.""" 918 cwd = self.cwd or self.fs._cwd 919 return cwd.Rfindalldirs(pathlist)
920 921 @SCons.Memoize.CountMethodCall
922 - def rentry(self):
923 try: 924 return self._memo['rentry'] 925 except KeyError: 926 pass 927 result = self 928 if not self.exists(): 929 norm_name = _my_normcase(self.name) 930 for dir in self.dir.get_all_rdirs(): 931 try: 932 node = dir.entries[norm_name] 933 except KeyError: 934 if dir.entry_exists_on_disk(self.name): 935 result = dir.Entry(self.name) 936 break 937 self._memo['rentry'] = result 938 return result
939
940 - def _glob1(self, pattern, ondisk=True, source=False, strings=False):
941 return []
942 943 # Dict that provides a simple backward compatibility 944 # layer for the Node attributes 'abspath', 'labspath', 945 # 'path', 'tpath' and 'path_elements'. 946 # @see Base.__getattr__ above 947 node_bwcomp = {'abspath' : Base.get_abspath, 948 'labspath' : Base.get_labspath, 949 'path' : Base.get_internal_path, 950 'tpath' : Base.get_tpath, 951 'path_elements' : Base.get_path_elements, 952 'suffix' : Base.get_suffix}
953 954 -class Entry(Base):
955 """This is the class for generic Node.FS entries--that is, things 956 that could be a File or a Dir, but we're just not sure yet. 957 Consequently, the methods in this class really exist just to 958 transform their associated object into the right class when the 959 time comes, and then call the same-named method in the transformed 960 class.""" 961 962 __slots__ = ['scanner_paths', 963 'cachedir_csig', 964 'cachesig', 965 'repositories', 966 'srcdir', 967 'entries', 968 'searched', 969 '_sconsign', 970 'variant_dirs', 971 'root', 972 'dirname', 973 'on_disk_entries', 974 'sccs_dir', 975 'rcs_dir', 976 'released_target_info', 977 'contentsig'] 978
979 - def __init__(self, name, directory, fs):
980 Base.__init__(self, name, directory, fs) 981 self._func_exists = 3 982 self._func_get_contents = 1
983
984 - def diskcheck_match(self):
985 pass
986
987 - def disambiguate(self, must_exist=None):
988 """ 989 """ 990 if self.isdir(): 991 self.__class__ = Dir 992 self._morph() 993 elif self.isfile(): 994 self.__class__ = File 995 self._morph() 996 self.clear() 997 else: 998 # There was nothing on-disk at this location, so look in 999 # the src directory. 1000 # 1001 # We can't just use self.srcnode() straight away because 1002 # that would create an actual Node for this file in the src 1003 # directory, and there might not be one. Instead, use the 1004 # dir_on_disk() method to see if there's something on-disk 1005 # with that name, in which case we can go ahead and call 1006 # self.srcnode() to create the right type of entry. 1007 srcdir = self.dir.srcnode() 1008 if srcdir != self.dir and \ 1009 srcdir.entry_exists_on_disk(self.name) and \ 1010 self.srcnode().isdir(): 1011 self.__class__ = Dir 1012 self._morph() 1013 elif must_exist: 1014 msg = "No such file or directory: '%s'" % self.get_abspath() 1015 raise SCons.Errors.UserError(msg) 1016 else: 1017 self.__class__ = File 1018 self._morph() 1019 self.clear() 1020 return self
1021
1022 - def rfile(self):
1023 """We're a generic Entry, but the caller is actually looking for 1024 a File at this point, so morph into one.""" 1025 self.__class__ = File 1026 self._morph() 1027 self.clear() 1028 return File.rfile(self)
1029
1030 - def scanner_key(self):
1031 return self.get_suffix()
1032
1033 - def get_contents(self):
1034 """Fetch the contents of the entry. Returns the exact binary 1035 contents of the file.""" 1036 return SCons.Node._get_contents_map[self._func_get_contents](self)
1037
1038 - def get_text_contents(self):
1039 """Fetch the decoded text contents of a Unicode encoded Entry. 1040 1041 Since this should return the text contents from the file 1042 system, we check to see into what sort of subclass we should 1043 morph this Entry.""" 1044 try: 1045 self = self.disambiguate(must_exist=1) 1046 except SCons.Errors.UserError: 1047 # There was nothing on disk with which to disambiguate 1048 # this entry. Leave it as an Entry, but return a null 1049 # string so calls to get_text_contents() in emitters and 1050 # the like (e.g. in qt.py) don't have to disambiguate by 1051 # hand or catch the exception. 1052 return '' 1053 else: 1054 return self.get_text_contents()
1055
1056 - def must_be_same(self, klass):
1057 """Called to make sure a Node is a Dir. Since we're an 1058 Entry, we can morph into one.""" 1059 if self.__class__ is not klass: 1060 self.__class__ = klass 1061 self._morph() 1062 self.clear()
1063 1064 # The following methods can get called before the Taskmaster has 1065 # had a chance to call disambiguate() directly to see if this Entry 1066 # should really be a Dir or a File. We therefore use these to call 1067 # disambiguate() transparently (from our caller's point of view). 1068 # 1069 # Right now, this minimal set of methods has been derived by just 1070 # looking at some of the methods that will obviously be called early 1071 # in any of the various Taskmasters' calling sequences, and then 1072 # empirically figuring out which additional methods are necessary 1073 # to make various tests pass. 1074
1075 - def exists(self):
1076 return SCons.Node._exists_map[self._func_exists](self)
1077
1078 - def rel_path(self, other):
1079 d = self.disambiguate() 1080 if d.__class__ is Entry: 1081 raise Exception("rel_path() could not disambiguate File/Dir") 1082 return d.rel_path(other)
1083
1084 - def new_ninfo(self):
1085 return self.disambiguate().new_ninfo()
1086
1087 - def _glob1(self, pattern, ondisk=True, source=False, strings=False):
1088 return self.disambiguate()._glob1(pattern, ondisk, source, strings)
1089
1090 - def get_subst_proxy(self):
1091 return self.disambiguate().get_subst_proxy()
1092 1093 # This is for later so we can differentiate between Entry the class and Entry 1094 # the method of the FS class. 1095 _classEntry = Entry
1096 1097 1098 -class LocalFS(object):
1099 1100 # This class implements an abstraction layer for operations involving 1101 # a local file system. Essentially, this wraps any function in 1102 # the os, os.path or shutil modules that we use to actually go do 1103 # anything with or to the local file system. 1104 # 1105 # Note that there's a very good chance we'll refactor this part of 1106 # the architecture in some way as we really implement the interface(s) 1107 # for remote file system Nodes. For example, the right architecture 1108 # might be to have this be a subclass instead of a base class. 1109 # Nevertheless, we're using this as a first step in that direction. 1110 # 1111 # We're not using chdir() yet because the calling subclass method 1112 # needs to use os.chdir() directly to avoid recursion. Will we 1113 # really need this one? 1114 #def chdir(self, path): 1115 # return os.chdir(path)
1116 - def chmod(self, path, mode):
1117 return os.chmod(path, mode)
1118 - def copy(self, src, dst):
1119 return shutil.copy(src, dst)
1120 - def copy2(self, src, dst):
1121 return shutil.copy2(src, dst)
1122 - def exists(self, path):
1123 return os.path.exists(path)
1124 - def getmtime(self, path):
1125 return os.path.getmtime(path)
1126 - def getsize(self, path):
1127 return os.path.getsize(path)
1128 - def isdir(self, path):
1129 return os.path.isdir(path)
1130 - def isfile(self, path):
1131 return os.path.isfile(path)
1134 - def lstat(self, path):
1135 return os.lstat(path)
1136 - def listdir(self, path):
1137 return os.listdir(path)
1138 - def makedirs(self, path):
1139 return os.makedirs(path)
1140 - def mkdir(self, path):
1141 return os.mkdir(path)
1142 - def rename(self, old, new):
1143 return os.rename(old, new)
1144 - def stat(self, path):
1145 return os.stat(path)
1148 - def open(self, path):
1149 return open(path)
1152 1153 if hasattr(os, 'symlink'): 1156 else: 1159 1160 if hasattr(os, 'readlink'): 1163 else:
1166
1167 1168 #class RemoteFS: 1169 # # Skeleton for the obvious methods we might need from the 1170 # # abstraction layer for a remote filesystem. 1171 # def upload(self, local_src, remote_dst): 1172 # pass 1173 # def download(self, remote_src, local_dst): 1174 # pass 1175 1176 1177 -class FS(LocalFS):
1178
1179 - def __init__(self, path = None):
1180 """Initialize the Node.FS subsystem. 1181 1182 The supplied path is the top of the source tree, where we 1183 expect to find the top-level build file. If no path is 1184 supplied, the current directory is the default. 1185 1186 The path argument must be a valid absolute path. 1187 """ 1188 if SCons.Debug.track_instances: logInstanceCreation(self, 'Node.FS') 1189 1190 self._memo = {} 1191 1192 self.Root = {} 1193 self.SConstruct_dir = None 1194 self.max_drift = default_max_drift 1195 1196 self.Top = None 1197 if path is None: 1198 self.pathTop = os.getcwd() 1199 else: 1200 self.pathTop = path 1201 self.defaultDrive = _my_normcase(_my_splitdrive(self.pathTop)[0]) 1202 1203 self.Top = self.Dir(self.pathTop) 1204 self.Top._path = '.' 1205 self.Top._tpath = '.' 1206 self._cwd = self.Top 1207 1208 DirNodeInfo.fs = self 1209 FileNodeInfo.fs = self
1210
1211 - def set_SConstruct_dir(self, dir):
1212 self.SConstruct_dir = dir
1213
1214 - def get_max_drift(self):
1215 return self.max_drift
1216
1217 - def set_max_drift(self, max_drift):
1218 self.max_drift = max_drift
1219
1220 - def getcwd(self):
1221 if hasattr(self, "_cwd"): 1222 return self._cwd 1223 else: 1224 return "<no cwd>"
1225
1226 - def chdir(self, dir, change_os_dir=0):
1227 """Change the current working directory for lookups. 1228 If change_os_dir is true, we will also change the "real" cwd 1229 to match. 1230 """ 1231 curr=self._cwd 1232 try: 1233 if dir is not None: 1234 self._cwd = dir 1235 if change_os_dir: 1236 os.chdir(dir.get_abspath()) 1237 except OSError: 1238 self._cwd = curr 1239 raise
1240
1241 - def get_root(self, drive):
1242 """ 1243 Returns the root directory for the specified drive, creating 1244 it if necessary. 1245 """ 1246 drive = _my_normcase(drive) 1247 try: 1248 return self.Root[drive] 1249 except KeyError: 1250 root = RootDir(drive, self) 1251 self.Root[drive] = root 1252 if not drive: 1253 self.Root[self.defaultDrive] = root 1254 elif drive == self.defaultDrive: 1255 self.Root[''] = root 1256 return root
1257
1258 - def _lookup(self, p, directory, fsclass, create=1):
1259 """ 1260 The generic entry point for Node lookup with user-supplied data. 1261 1262 This translates arbitrary input into a canonical Node.FS object 1263 of the specified fsclass. The general approach for strings is 1264 to turn it into a fully normalized absolute path and then call 1265 the root directory's lookup_abs() method for the heavy lifting. 1266 1267 If the path name begins with '#', it is unconditionally 1268 interpreted relative to the top-level directory of this FS. '#' 1269 is treated as a synonym for the top-level SConstruct directory, 1270 much like '~' is treated as a synonym for the user's home 1271 directory in a UNIX shell. So both '#foo' and '#/foo' refer 1272 to the 'foo' subdirectory underneath the top-level SConstruct 1273 directory. 1274 1275 If the path name is relative, then the path is looked up relative 1276 to the specified directory, or the current directory (self._cwd, 1277 typically the SConscript directory) if the specified directory 1278 is None. 1279 """ 1280 if isinstance(p, Base): 1281 # It's already a Node.FS object. Make sure it's the right 1282 # class and return. 1283 p.must_be_same(fsclass) 1284 return p 1285 # str(p) in case it's something like a proxy object 1286 p = str(p) 1287 1288 if not os_sep_is_slash: 1289 p = p.replace(OS_SEP, '/') 1290 1291 if p[0:1] == '#': 1292 # There was an initial '#', so we strip it and override 1293 # whatever directory they may have specified with the 1294 # top-level SConstruct directory. 1295 p = p[1:] 1296 directory = self.Top 1297 1298 # There might be a drive letter following the 1299 # '#'. Although it is not described in the SCons man page, 1300 # the regression test suite explicitly tests for that 1301 # syntax. It seems to mean the following thing: 1302 # 1303 # Assuming the the SCons top dir is in C:/xxx/yyy, 1304 # '#X:/toto' means X:/xxx/yyy/toto. 1305 # 1306 # i.e. it assumes that the X: drive has a directory 1307 # structure similar to the one found on drive C:. 1308 if do_splitdrive: 1309 drive, p = _my_splitdrive(p) 1310 if drive: 1311 root = self.get_root(drive) 1312 else: 1313 root = directory.root 1314 else: 1315 root = directory.root 1316 1317 # We can only strip trailing after splitting the drive 1318 # since the drive might the UNC '//' prefix. 1319 p = p.strip('/') 1320 1321 needs_normpath = needs_normpath_match(p) 1322 1323 # The path is relative to the top-level SCons directory. 1324 if p in ('', '.'): 1325 p = directory.get_labspath() 1326 else: 1327 p = directory.get_labspath() + '/' + p 1328 else: 1329 if do_splitdrive: 1330 drive, p = _my_splitdrive(p) 1331 if drive and not p: 1332 # This causes a naked drive letter to be treated 1333 # as a synonym for the root directory on that 1334 # drive. 1335 p = '/' 1336 else: 1337 drive = '' 1338 1339 # We can only strip trailing '/' since the drive might the 1340 # UNC '//' prefix. 1341 if p != '/': 1342 p = p.rstrip('/') 1343 1344 needs_normpath = needs_normpath_match(p) 1345 1346 if p[0:1] == '/': 1347 # Absolute path 1348 root = self.get_root(drive) 1349 else: 1350 # This is a relative lookup or to the current directory 1351 # (the path name is not absolute). Add the string to the 1352 # appropriate directory lookup path, after which the whole 1353 # thing gets normalized. 1354 if directory: 1355 if not isinstance(directory, Dir): 1356 directory = self.Dir(directory) 1357 else: 1358 directory = self._cwd 1359 1360 if p in ('', '.'): 1361 p = directory.get_labspath() 1362 else: 1363 p = directory.get_labspath() + '/' + p 1364 1365 if drive: 1366 root = self.get_root(drive) 1367 else: 1368 root = directory.root 1369 1370 if needs_normpath is not None: 1371 # Normalize a pathname. Will return the same result for 1372 # equivalent paths. 1373 # 1374 # We take advantage of the fact that we have an absolute 1375 # path here for sure. In addition, we know that the 1376 # components of lookup path are separated by slashes at 1377 # this point. Because of this, this code is about 2X 1378 # faster than calling os.path.normpath() followed by 1379 # replacing os.sep with '/' again. 1380 ins = p.split('/')[1:] 1381 outs = [] 1382 for d in ins: 1383 if d == '..': 1384 try: 1385 outs.pop() 1386 except IndexError: 1387 pass 1388 elif d not in ('', '.'): 1389 outs.append(d) 1390 p = '/' + '/'.join(outs) 1391 1392 return root._lookup_abs(p, fsclass, create)
1393
1394 - def Entry(self, name, directory = None, create = 1):
1395 """Look up or create a generic Entry node with the specified name. 1396 If the name is a relative path (begins with ./, ../, or a file 1397 name), then it is looked up relative to the supplied directory 1398 node, or to the top level directory of the FS (supplied at 1399 construction time) if no directory is supplied. 1400 """ 1401 return self._lookup(name, directory, Entry, create)
1402
1403 - def File(self, name, directory = None, create = 1):
1404 """Look up or create a File node with the specified name. If 1405 the name is a relative path (begins with ./, ../, or a file name), 1406 then it is looked up relative to the supplied directory node, 1407 or to the top level directory of the FS (supplied at construction 1408 time) if no directory is supplied. 1409 1410 This method will raise TypeError if a directory is found at the 1411 specified path. 1412 """ 1413 return self._lookup(name, directory, File, create)
1414
1415 - def Dir(self, name, directory = None, create = True):
1416 """Look up or create a Dir node with the specified name. If 1417 the name is a relative path (begins with ./, ../, or a file name), 1418 then it is looked up relative to the supplied directory node, 1419 or to the top level directory of the FS (supplied at construction 1420 time) if no directory is supplied. 1421 1422 This method will raise TypeError if a normal file is found at the 1423 specified path. 1424 """ 1425 return self._lookup(name, directory, Dir, create)
1426
1427 - def VariantDir(self, variant_dir, src_dir, duplicate=1):
1428 """Link the supplied variant directory to the source directory 1429 for purposes of building files.""" 1430 1431 if not isinstance(src_dir, SCons.Node.Node): 1432 src_dir = self.Dir(src_dir) 1433 if not isinstance(variant_dir, SCons.Node.Node): 1434 variant_dir = self.Dir(variant_dir) 1435 if src_dir.is_under(variant_dir): 1436 raise SCons.Errors.UserError("Source directory cannot be under variant directory.") 1437 if variant_dir.srcdir: 1438 if variant_dir.srcdir == src_dir: 1439 return # We already did this. 1440 raise SCons.Errors.UserError("'%s' already has a source directory: '%s'."%(variant_dir, variant_dir.srcdir)) 1441 variant_dir.link(src_dir, duplicate)
1442
1443 - def Repository(self, *dirs):
1444 """Specify Repository directories to search.""" 1445 for d in dirs: 1446 if not isinstance(d, SCons.Node.Node): 1447 d = self.Dir(d) 1448 self.Top.addRepository(d)
1449
1450 - def variant_dir_target_climb(self, orig, dir, tail):
1451 """Create targets in corresponding variant directories 1452 1453 Climb the directory tree, and look up path names 1454 relative to any linked variant directories we find. 1455 1456 Even though this loops and walks up the tree, we don't memoize 1457 the return value because this is really only used to process 1458 the command-line targets. 1459 """ 1460 targets = [] 1461 message = None 1462 fmt = "building associated VariantDir targets: %s" 1463 start_dir = dir 1464 while dir: 1465 for bd in dir.variant_dirs: 1466 if start_dir.is_under(bd): 1467 # If already in the build-dir location, don't reflect 1468 return [orig], fmt % str(orig) 1469 p = os.path.join(bd._path, *tail) 1470 targets.append(self.Entry(p)) 1471 tail = [dir.name] + tail 1472 dir = dir.up() 1473 if targets: 1474 message = fmt % ' '.join(map(str, targets)) 1475 return targets, message
1476
1477 - def Glob(self, pathname, ondisk=True, source=True, strings=False, exclude=None, cwd=None):
1478 """ 1479 Globs 1480 1481 This is mainly a shim layer 1482 """ 1483 if cwd is None: 1484 cwd = self.getcwd() 1485 return cwd.glob(pathname, ondisk, source, strings, exclude)
1486
1487 -class DirNodeInfo(SCons.Node.NodeInfoBase):
1488 __slots__ = () 1489 # This should get reset by the FS initialization. 1490 current_version_id = 2 1491 1492 fs = None 1493
1494 - def str_to_node(self, s):
1495 top = self.fs.Top 1496 root = top.root 1497 if do_splitdrive: 1498 drive, s = _my_splitdrive(s) 1499 if drive: 1500 root = self.fs.get_root(drive) 1501 if not os.path.isabs(s): 1502 s = top.get_labspath() + '/' + s 1503 return root._lookup_abs(s, Entry)
1504
1505 -class DirBuildInfo(SCons.Node.BuildInfoBase):
1506 __slots__ = () 1507 current_version_id = 2
1508 1509 glob_magic_check = re.compile('[*?[]')
1510 1511 -def has_glob_magic(s):
1512 return glob_magic_check.search(s) is not None
1513
1514 -class Dir(Base):
1515 """A class for directories in a file system. 1516 """ 1517 1518 __slots__ = ['scanner_paths', 1519 'cachedir_csig', 1520 'cachesig', 1521 'repositories', 1522 'srcdir', 1523 'entries', 1524 'searched', 1525 '_sconsign', 1526 'variant_dirs', 1527 'root', 1528 'dirname', 1529 'on_disk_entries', 1530 'sccs_dir', 1531 'rcs_dir', 1532 'released_target_info', 1533 'contentsig'] 1534 1535 NodeInfo = DirNodeInfo 1536 BuildInfo = DirBuildInfo 1537
1538 - def __init__(self, name, directory, fs):
1539 if SCons.Debug.track_instances: logInstanceCreation(self, 'Node.FS.Dir') 1540 Base.__init__(self, name, directory, fs) 1541 self._morph()
1542
1543 - def _morph(self):
1544 """Turn a file system Node (either a freshly initialized directory 1545 object or a separate Entry object) into a proper directory object. 1546 1547 Set up this directory's entries and hook it into the file 1548 system tree. Specify that directories (this Node) don't use 1549 signatures for calculating whether they're current. 1550 """ 1551 1552 self.repositories = [] 1553 self.srcdir = None 1554 1555 self.entries = {} 1556 self.entries['.'] = self 1557 self.entries['..'] = self.dir 1558 self.cwd = self 1559 self.searched = 0 1560 self._sconsign = None 1561 self.variant_dirs = [] 1562 self.root = self.dir.root 1563 self.changed_since_last_build = 3 1564 self._func_sconsign = 1 1565 self._func_exists = 2 1566 self._func_get_contents = 2 1567 1568 self._abspath = SCons.Util.silent_intern(self.dir.entry_abspath(self.name)) 1569 self._labspath = SCons.Util.silent_intern(self.dir.entry_labspath(self.name)) 1570 if self.dir._path == '.': 1571 self._path = SCons.Util.silent_intern(self.name) 1572 else: 1573 self._path = SCons.Util.silent_intern(self.dir.entry_path(self.name)) 1574 if self.dir._tpath == '.': 1575 self._tpath = SCons.Util.silent_intern(self.name) 1576 else: 1577 self._tpath = SCons.Util.silent_intern(self.dir.entry_tpath(self.name)) 1578 self._path_elements = self.dir._path_elements + [self] 1579 1580 # For directories, we make a difference between the directory 1581 # 'name' and the directory 'dirname'. The 'name' attribute is 1582 # used when we need to print the 'name' of the directory or 1583 # when we it is used as the last part of a path. The 'dirname' 1584 # is used when the directory is not the last element of the 1585 # path. The main reason for making that distinction is that 1586 # for RoorDir's the dirname can not be easily inferred from 1587 # the name. For example, we have to add a '/' after a drive 1588 # letter but not after a UNC path prefix ('//'). 1589 self.dirname = self.name + OS_SEP 1590 1591 # Don't just reset the executor, replace its action list, 1592 # because it might have some pre-or post-actions that need to 1593 # be preserved. 1594 # 1595 # But don't reset the executor if there is a non-null executor 1596 # attached already. The existing executor might have other 1597 # targets, in which case replacing the action list with a 1598 # Mkdir action is a big mistake. 1599 if not hasattr(self, 'executor'): 1600 self.builder = get_MkdirBuilder() 1601 self.get_executor().set_action_list(self.builder.action) 1602 else: 1603 # Prepend MkdirBuilder action to existing action list 1604 l = self.get_executor().action_list 1605 a = get_MkdirBuilder().action 1606 l.insert(0, a) 1607 self.get_executor().set_action_list(l)
1608
1609 - def diskcheck_match(self):
1610 diskcheck_match(self, self.isfile, 1611 "File %s found where directory expected.")
1612
1613 - def __clearRepositoryCache(self, duplicate=None):
1614 """Called when we change the repository(ies) for a directory. 1615 This clears any cached information that is invalidated by changing 1616 the repository.""" 1617 1618 for node in self.entries.values(): 1619 if node != self.dir: 1620 if node != self and isinstance(node, Dir): 1621 node.__clearRepositoryCache(duplicate) 1622 else: 1623 node.clear() 1624 try: 1625 del node._srcreps 1626 except AttributeError: 1627 pass 1628 if duplicate is not None: 1629 node.duplicate=duplicate
1630
1631 - def __resetDuplicate(self, node):
1632 if node != self: 1633 node.duplicate = node.get_dir().duplicate
1634
1635 - def Entry(self, name):
1636 """ 1637 Looks up or creates an entry node named 'name' relative to 1638 this directory. 1639 """ 1640 return self.fs.Entry(name, self)
1641
1642 - def Dir(self, name, create=True):
1643 """ 1644 Looks up or creates a directory node named 'name' relative to 1645 this directory. 1646 """ 1647 return self.fs.Dir(name, self, create)
1648
1649 - def File(self, name):
1650 """ 1651 Looks up or creates a file node named 'name' relative to 1652 this directory. 1653 """ 1654 return self.fs.File(name, self)
1655 1663
1664 - def getRepositories(self):
1665 """Returns a list of repositories for this directory. 1666 """ 1667 if self.srcdir and not self.duplicate: 1668 return self.srcdir.get_all_rdirs() + self.repositories 1669 return self.repositories
1670 1671 @SCons.Memoize.CountMethodCall
1672 - def get_all_rdirs(self):
1673 try: 1674 return list(self._memo['get_all_rdirs']) 1675 except KeyError: 1676 pass 1677 1678 result = [self] 1679 fname = '.' 1680 dir = self 1681 while dir: 1682 for rep in dir.getRepositories(): 1683 result.append(rep.Dir(fname)) 1684 if fname == '.': 1685 fname = dir.name 1686 else: 1687 fname = dir.name + OS_SEP + fname 1688 dir = dir.up() 1689 1690 self._memo['get_all_rdirs'] = list(result) 1691 1692 return result
1693
1694 - def addRepository(self, dir):
1695 if dir != self and not dir in self.repositories: 1696 self.repositories.append(dir) 1697 dir._tpath = '.' 1698 self.__clearRepositoryCache()
1699
1700 - def up(self):
1701 return self.dir
1702
1703 - def _rel_path_key(self, other):
1704 return str(other)
1705 1706 @SCons.Memoize.CountDictCall(_rel_path_key)
1707 - def rel_path(self, other):
1708 """Return a path to "other" relative to this directory. 1709 """ 1710 1711 # This complicated and expensive method, which constructs relative 1712 # paths between arbitrary Node.FS objects, is no longer used 1713 # by SCons itself. It was introduced to store dependency paths 1714 # in .sconsign files relative to the target, but that ended up 1715 # being significantly inefficient. 1716 # 1717 # We're continuing to support the method because some SConstruct 1718 # files out there started using it when it was available, and 1719 # we're all about backwards compatibility.. 1720 1721 try: 1722 memo_dict = self._memo['rel_path'] 1723 except KeyError: 1724 memo_dict = {} 1725 self._memo['rel_path'] = memo_dict 1726 else: 1727 try: 1728 return memo_dict[other] 1729 except KeyError: 1730 pass 1731 1732 if self is other: 1733 result = '.' 1734 1735 elif not other in self._path_elements: 1736 try: 1737 other_dir = other.get_dir() 1738 except AttributeError: 1739 result = str(other) 1740 else: 1741 if other_dir is None: 1742 result = other.name 1743 else: 1744 dir_rel_path = self.rel_path(other_dir) 1745 if dir_rel_path == '.': 1746 result = other.name 1747 else: 1748 result = dir_rel_path + OS_SEP + other.name 1749 else: 1750 i = self._path_elements.index(other) + 1 1751 1752 path_elems = ['..'] * (len(self._path_elements) - i) \ 1753 + [n.name for n in other._path_elements[i:]] 1754 1755 result = OS_SEP.join(path_elems) 1756 1757 memo_dict[other] = result 1758 1759 return result
1760
1761 - def get_env_scanner(self, env, kw={}):
1762 import SCons.Defaults 1763 return SCons.Defaults.DirEntryScanner
1764
1765 - def get_target_scanner(self):
1766 import SCons.Defaults 1767 return SCons.Defaults.DirEntryScanner
1768
1769 - def get_found_includes(self, env, scanner, path):
1770 """Return this directory's implicit dependencies. 1771 1772 We don't bother caching the results because the scan typically 1773 shouldn't be requested more than once (as opposed to scanning 1774 .h file contents, which can be requested as many times as the 1775 files is #included by other files). 1776 """ 1777 if not scanner: 1778 return [] 1779 # Clear cached info for this Dir. If we already visited this 1780 # directory on our walk down the tree (because we didn't know at 1781 # that point it was being used as the source for another Node) 1782 # then we may have calculated build signature before realizing 1783 # we had to scan the disk. Now that we have to, though, we need 1784 # to invalidate the old calculated signature so that any node 1785 # dependent on our directory structure gets one that includes 1786 # info about everything on disk. 1787 self.clear() 1788 return scanner(self, env, path)
1789 1790 # 1791 # Taskmaster interface subsystem 1792 # 1793
1794 - def prepare(self):
1795 pass
1796
1797 - def build(self, **kw):
1798 """A null "builder" for directories.""" 1799 global MkdirBuilder 1800 if self.builder is not MkdirBuilder: 1801 SCons.Node.Node.build(self, **kw)
1802 1803 # 1804 # 1805 # 1806
1807 - def _create(self):
1808 """Create this directory, silently and without worrying about 1809 whether the builder is the default or not.""" 1810 listDirs = [] 1811 parent = self 1812 while parent: 1813 if parent.exists(): 1814 break 1815 listDirs.append(parent) 1816 p = parent.up() 1817 if p is None: 1818 # Don't use while: - else: for this condition because 1819 # if so, then parent is None and has no .path attribute. 1820 raise SCons.Errors.StopError(parent._path) 1821 parent = p 1822 listDirs.reverse() 1823 for dirnode in listDirs: 1824 try: 1825 # Don't call dirnode.build(), call the base Node method 1826 # directly because we definitely *must* create this 1827 # directory. The dirnode.build() method will suppress 1828 # the build if it's the default builder. 1829 SCons.Node.Node.build(dirnode) 1830 dirnode.get_executor().nullify() 1831 # The build() action may or may not have actually 1832 # created the directory, depending on whether the -n 1833 # option was used or not. Delete the _exists and 1834 # _rexists attributes so they can be reevaluated. 1835 dirnode.clear() 1836 except OSError: 1837 pass
1838
1840 global MkdirBuilder 1841 return self.builder is not MkdirBuilder and self.has_builder()
1842
1843 - def alter_targets(self):
1844 """Return any corresponding targets in a variant directory. 1845 """ 1846 return self.fs.variant_dir_target_climb(self, self, [])
1847
1848 - def scanner_key(self):
1849 """A directory does not get scanned.""" 1850 return None
1851
1852 - def get_text_contents(self):
1853 """We already emit things in text, so just return the binary 1854 version.""" 1855 return self.get_contents()
1856
1857 - def get_contents(self):
1858 """Return content signatures and names of all our children 1859 separated by new-lines. Ensure that the nodes are sorted.""" 1860 return SCons.Node._get_contents_map[self._func_get_contents](self)
1861
1862 - def get_csig(self):
1863 """Compute the content signature for Directory nodes. In 1864 general, this is not needed and the content signature is not 1865 stored in the DirNodeInfo. However, if get_contents on a Dir 1866 node is called which has a child directory, the child 1867 directory should return the hash of its contents.""" 1868 contents = self.get_contents() 1869 return SCons.Util.MD5signature(contents)
1870
1871 - def do_duplicate(self, src):
1872 pass
1873
1874 - def is_up_to_date(self):
1875 """If any child is not up-to-date, then this directory isn't, 1876 either.""" 1877 if self.builder is not MkdirBuilder and not self.exists(): 1878 return 0 1879 up_to_date = SCons.Node.up_to_date 1880 for kid in self.children(): 1881 if kid.get_state() > up_to_date: 1882 return 0 1883 return 1
1884
1885 - def rdir(self):
1886 if not self.exists(): 1887 norm_name = _my_normcase(self.name) 1888 for dir in self.dir.get_all_rdirs(): 1889 try: node = dir.entries[norm_name] 1890 except KeyError: node = dir.dir_on_disk(self.name) 1891 if node and node.exists() and \ 1892 (isinstance(dir, Dir) or isinstance(dir, Entry)): 1893 return node 1894 return self
1895
1896 - def sconsign(self):
1897 """Return the .sconsign file info for this directory. """ 1898 return _sconsign_map[self._func_sconsign](self)
1899
1900 - def srcnode(self):
1901 """Dir has a special need for srcnode()...if we 1902 have a srcdir attribute set, then that *is* our srcnode.""" 1903 if self.srcdir: 1904 return self.srcdir 1905 return Base.srcnode(self)
1906
1907 - def get_timestamp(self):
1908 """Return the latest timestamp from among our children""" 1909 stamp = 0 1910 for kid in self.children(): 1911 if kid.get_timestamp() > stamp: 1912 stamp = kid.get_timestamp() 1913 return stamp
1914
1915 - def get_abspath(self):
1916 """Get the absolute path of the file.""" 1917 return self._abspath
1918
1919 - def get_labspath(self):
1920 """Get the absolute path of the file.""" 1921 return self._labspath
1922
1923 - def get_internal_path(self):
1924 return self._path
1925
1926 - def get_tpath(self):
1927 return self._tpath
1928
1929 - def get_path_elements(self):
1930 return self._path_elements
1931
1932 - def entry_abspath(self, name):
1933 return self._abspath + OS_SEP + name
1934
1935 - def entry_labspath(self, name):
1936 return self._labspath + '/' + name
1937
1938 - def entry_path(self, name):
1939 return self._path + OS_SEP + name
1940
1941 - def entry_tpath(self, name):
1942 return self._tpath + OS_SEP + name
1943
1944 - def entry_exists_on_disk(self, name):
1945 """ Searches through the file/dir entries of the current 1946 directory, and returns True if a physical entry with the given 1947 name could be found. 1948 1949 @see rentry_exists_on_disk 1950 """ 1951 try: 1952 d = self.on_disk_entries 1953 except AttributeError: 1954 d = {} 1955 try: 1956 entries = os.listdir(self._abspath) 1957 except OSError: 1958 pass 1959 else: 1960 for entry in map(_my_normcase, entries): 1961 d[entry] = True 1962 self.on_disk_entries = d 1963 if sys.platform == 'win32' or sys.platform == 'cygwin': 1964 name = _my_normcase(name) 1965 result = d.get(name) 1966 if result is None: 1967 # Belt-and-suspenders for Windows: check directly for 1968 # 8.3 file names that don't show up in os.listdir(). 1969 result = os.path.exists(self._abspath + OS_SEP + name) 1970 d[name] = result 1971 return result 1972 else: 1973 return name in d
1974
1975 - def rentry_exists_on_disk(self, name):
1976 """ Searches through the file/dir entries of the current 1977 *and* all its remote directories (repos), and returns 1978 True if a physical entry with the given name could be found. 1979 The local directory (self) gets searched first, so 1980 repositories take a lower precedence regarding the 1981 searching order. 1982 1983 @see entry_exists_on_disk 1984 """ 1985 1986 rentry_exists = self.entry_exists_on_disk(name) 1987 if not rentry_exists: 1988 # Search through the repository folders 1989 norm_name = _my_normcase(name) 1990 for rdir in self.get_all_rdirs(): 1991 try: 1992 node = rdir.entries[norm_name] 1993 if node: 1994 rentry_exists = True 1995 break 1996 except KeyError: 1997 if rdir.entry_exists_on_disk(name): 1998 rentry_exists = True 1999 break 2000 return rentry_exists
2001 2002 @SCons.Memoize.CountMethodCall
2003 - def srcdir_list(self):
2004 try: 2005 return self._memo['srcdir_list'] 2006 except KeyError: 2007 pass 2008 2009 result = [] 2010 2011 dirname = '.' 2012 dir = self 2013 while dir: 2014 if dir.srcdir: 2015 result.append(dir.srcdir.Dir(dirname)) 2016 dirname = dir.name + OS_SEP + dirname 2017 dir = dir.up() 2018 2019 self._memo['srcdir_list'] = result 2020 2021 return result
2022
2023 - def srcdir_duplicate(self, name):
2024 for dir in self.srcdir_list(): 2025 if self.is_under(dir): 2026 # We shouldn't source from something in the build path; 2027 # variant_dir is probably under src_dir, in which case 2028 # we are reflecting. 2029 break 2030 if dir.entry_exists_on_disk(name): 2031 srcnode = dir.Entry(name).disambiguate() 2032 if self.duplicate: 2033 node = self.Entry(name).disambiguate() 2034 node.do_duplicate(srcnode) 2035 return node 2036 else: 2037 return srcnode 2038 return None
2039
2040 - def _srcdir_find_file_key(self, filename):
2041 return filename
2042 2043 @SCons.Memoize.CountDictCall(_srcdir_find_file_key)
2044 - def srcdir_find_file(self, filename):
2045 try: 2046 memo_dict = self._memo['srcdir_find_file'] 2047 except KeyError: 2048 memo_dict = {} 2049 self._memo['srcdir_find_file'] = memo_dict 2050 else: 2051 try: 2052 return memo_dict[filename] 2053 except KeyError: 2054 pass 2055 2056 def func(node): 2057 if (isinstance(node, File) or isinstance(node, Entry)) and \ 2058 (node.is_derived() or node.exists()): 2059 return node 2060 return None
2061 2062 norm_name = _my_normcase(filename) 2063 2064 for rdir in self.get_all_rdirs(): 2065 try: node = rdir.entries[norm_name] 2066 except KeyError: node = rdir.file_on_disk(filename) 2067 else: node = func(node) 2068 if node: 2069 result = (node, self) 2070 memo_dict[filename] = result 2071 return result 2072 2073 for srcdir in self.srcdir_list(): 2074 for rdir in srcdir.get_all_rdirs(): 2075 try: node = rdir.entries[norm_name] 2076 except KeyError: node = rdir.file_on_disk(filename) 2077 else: node = func(node) 2078 if node: 2079 result = (File(filename, self, self.fs), srcdir) 2080 memo_dict[filename] = result 2081 return result 2082 2083 result = (None, None) 2084 memo_dict[filename] = result 2085 return result
2086
2087 - def dir_on_disk(self, name):
2088 if self.entry_exists_on_disk(name): 2089 try: return self.Dir(name) 2090 except TypeError: pass 2091 node = self.srcdir_duplicate(name) 2092 if isinstance(node, File): 2093 return None 2094 return node
2095
2096 - def file_on_disk(self, name):
2097 if self.entry_exists_on_disk(name) or \ 2098 diskcheck_rcs(self, name) or \ 2099 diskcheck_sccs(self, name): 2100 try: return self.File(name) 2101 except TypeError: pass 2102 node = self.srcdir_duplicate(name) 2103 if isinstance(node, Dir): 2104 return None 2105 return node
2106
2107 - def walk(self, func, arg):
2108 """ 2109 Walk this directory tree by calling the specified function 2110 for each directory in the tree. 2111 2112 This behaves like the os.path.walk() function, but for in-memory 2113 Node.FS.Dir objects. The function takes the same arguments as 2114 the functions passed to os.path.walk(): 2115 2116 func(arg, dirname, fnames) 2117 2118 Except that "dirname" will actually be the directory *Node*, 2119 not the string. The '.' and '..' entries are excluded from 2120 fnames. The fnames list may be modified in-place to filter the 2121 subdirectories visited or otherwise impose a specific order. 2122 The "arg" argument is always passed to func() and may be used 2123 in any way (or ignored, passing None is common). 2124 """ 2125 entries = self.entries 2126 names = list(entries.keys()) 2127 names.remove('.') 2128 names.remove('..') 2129 func(arg, self, names) 2130 for dirname in [n for n in names if isinstance(entries[n], Dir)]: 2131 entries[dirname].walk(func, arg)
2132
2133 - def glob(self, pathname, ondisk=True, source=False, strings=False, exclude=None):
2134 """ 2135 Returns a list of Nodes (or strings) matching a specified 2136 pathname pattern. 2137 2138 Pathname patterns follow UNIX shell semantics: * matches 2139 any-length strings of any characters, ? matches any character, 2140 and [] can enclose lists or ranges of characters. Matches do 2141 not span directory separators. 2142 2143 The matches take into account Repositories, returning local 2144 Nodes if a corresponding entry exists in a Repository (either 2145 an in-memory Node or something on disk). 2146 2147 By defafult, the glob() function matches entries that exist 2148 on-disk, in addition to in-memory Nodes. Setting the "ondisk" 2149 argument to False (or some other non-true value) causes the glob() 2150 function to only match in-memory Nodes. The default behavior is 2151 to return both the on-disk and in-memory Nodes. 2152 2153 The "source" argument, when true, specifies that corresponding 2154 source Nodes must be returned if you're globbing in a build 2155 directory (initialized with VariantDir()). The default behavior 2156 is to return Nodes local to the VariantDir(). 2157 2158 The "strings" argument, when true, returns the matches as strings, 2159 not Nodes. The strings are path names relative to this directory. 2160 2161 The "exclude" argument, if not None, must be a pattern or a list 2162 of patterns following the same UNIX shell semantics. 2163 Elements matching a least one pattern of this list will be excluded 2164 from the result. 2165 2166 The underlying algorithm is adapted from the glob.glob() function 2167 in the Python library (but heavily modified), and uses fnmatch() 2168 under the covers. 2169 """ 2170 dirname, basename = os.path.split(pathname) 2171 if not dirname: 2172 result = self._glob1(basename, ondisk, source, strings) 2173 else: 2174 if has_glob_magic(dirname): 2175 list = self.glob(dirname, ondisk, source, False, exclude) 2176 else: 2177 list = [self.Dir(dirname, create=True)] 2178 result = [] 2179 for dir in list: 2180 r = dir._glob1(basename, ondisk, source, strings) 2181 if strings: 2182 r = [os.path.join(str(dir), x) for x in r] 2183 result.extend(r) 2184 if exclude: 2185 excludes = [] 2186 excludeList = SCons.Util.flatten(exclude) 2187 for x in excludeList: 2188 r = self.glob(x, ondisk, source, strings) 2189 excludes.extend(r) 2190 result = filter(lambda x: not any(fnmatch.fnmatch(str(x), str(e)) for e in SCons.Util.flatten(excludes)), result) 2191 return sorted(result, key=lambda a: str(a))
2192
2193 - def _glob1(self, pattern, ondisk=True, source=False, strings=False):
2194 """ 2195 Globs for and returns a list of entry names matching a single 2196 pattern in this directory. 2197 2198 This searches any repositories and source directories for 2199 corresponding entries and returns a Node (or string) relative 2200 to the current directory if an entry is found anywhere. 2201 2202 TODO: handle pattern with no wildcard 2203 """ 2204 search_dir_list = self.get_all_rdirs() 2205 for srcdir in self.srcdir_list(): 2206 search_dir_list.extend(srcdir.get_all_rdirs()) 2207 2208 selfEntry = self.Entry 2209 names = [] 2210 for dir in search_dir_list: 2211 # We use the .name attribute from the Node because the keys of 2212 # the dir.entries dictionary are normalized (that is, all upper 2213 # case) on case-insensitive systems like Windows. 2214 node_names = [ v.name for k, v in dir.entries.items() 2215 if k not in ('.', '..') ] 2216 names.extend(node_names) 2217 if not strings: 2218 # Make sure the working directory (self) actually has 2219 # entries for all Nodes in repositories or variant dirs. 2220 for name in node_names: selfEntry(name) 2221 if ondisk: 2222 try: 2223 disk_names = os.listdir(dir._abspath) 2224 except os.error: 2225 continue 2226 names.extend(disk_names) 2227 if not strings: 2228 # We're going to return corresponding Nodes in 2229 # the local directory, so we need to make sure 2230 # those Nodes exist. We only want to create 2231 # Nodes for the entries that will match the 2232 # specified pattern, though, which means we 2233 # need to filter the list here, even though 2234 # the overall list will also be filtered later, 2235 # after we exit this loop. 2236 if pattern[0] != '.': 2237 #disk_names = [ d for d in disk_names if d[0] != '.' ] 2238 disk_names = [x for x in disk_names if x[0] != '.'] 2239 disk_names = fnmatch.filter(disk_names, pattern) 2240 dirEntry = dir.Entry 2241 for name in disk_names: 2242 # Add './' before disk filename so that '#' at 2243 # beginning of filename isn't interpreted. 2244 name = './' + name 2245 node = dirEntry(name).disambiguate() 2246 n = selfEntry(name) 2247 if n.__class__ != node.__class__: 2248 n.__class__ = node.__class__ 2249 n._morph() 2250 2251 names = set(names) 2252 if pattern[0] != '.': 2253 names = [x for x in names if x[0] != '.'] 2254 names = fnmatch.filter(names, pattern) 2255 2256 if strings: 2257 return names 2258 2259 return [self.entries[_my_normcase(n)] for n in names]
2260
2261 -class RootDir(Dir):
2262 """A class for the root directory of a file system. 2263 2264 This is the same as a Dir class, except that the path separator 2265 ('/' or '\\') is actually part of the name, so we don't need to 2266 add a separator when creating the path names of entries within 2267 this directory. 2268 """ 2269 2270 __slots__ = ['_lookupDict'] 2271
2272 - def __init__(self, drive, fs):
2273 if SCons.Debug.track_instances: logInstanceCreation(self, 'Node.FS.RootDir') 2274 SCons.Node.Node.__init__(self) 2275 2276 # Handle all the types of drives: 2277 if drive == '': 2278 # No drive, regular UNIX root or Windows default drive. 2279 name = OS_SEP 2280 dirname = OS_SEP 2281 elif drive == '//': 2282 # UNC path 2283 name = UNC_PREFIX 2284 dirname = UNC_PREFIX 2285 else: 2286 # Windows drive letter 2287 name = drive 2288 dirname = drive + OS_SEP 2289 2290 #: Filename with extension as it was specified when the object was 2291 #: created; to obtain filesystem path, use Python str() function 2292 self.name = SCons.Util.silent_intern(name) 2293 self.fs = fs #: Reference to parent Node.FS object 2294 2295 self._path_elements = [self] 2296 self.dir = self 2297 self._func_rexists = 2 2298 self._func_target_from_source = 1 2299 self.store_info = 1 2300 2301 # Now set our paths to what we really want them to be. The 2302 # name should already contain any necessary separators, such 2303 # as the initial drive letter (the name) plus the directory 2304 # separator, except for the "lookup abspath," which does not 2305 # have the drive letter. 2306 self._abspath = dirname 2307 self._labspath = '' 2308 self._path = dirname 2309 self._tpath = dirname 2310 self.dirname = dirname 2311 2312 self._morph() 2313 2314 self.duplicate = 0 2315 self._lookupDict = {} 2316 2317 self._lookupDict[''] = self 2318 self._lookupDict['/'] = self 2319 self.root = self 2320 # The // entry is necessary because os.path.normpath() 2321 # preserves double slashes at the beginning of a path on Posix 2322 # platforms. 2323 if not has_unc: 2324 self._lookupDict['//'] = self
2325
2326 - def _morph(self):
2327 """Turn a file system Node (either a freshly initialized directory 2328 object or a separate Entry object) into a proper directory object. 2329 2330 Set up this directory's entries and hook it into the file 2331 system tree. Specify that directories (this Node) don't use 2332 signatures for calculating whether they're current. 2333 """ 2334 2335 self.repositories = [] 2336 self.srcdir = None 2337 2338 self.entries = {} 2339 self.entries['.'] = self 2340 self.entries['..'] = self.dir 2341 self.cwd = self 2342 self.searched = 0 2343 self._sconsign = None 2344 self.variant_dirs = [] 2345 self.changed_since_last_build = 3 2346 self._func_sconsign = 1 2347 self._func_exists = 2 2348 self._func_get_contents = 2 2349 2350 # Don't just reset the executor, replace its action list, 2351 # because it might have some pre-or post-actions that need to 2352 # be preserved. 2353 # 2354 # But don't reset the executor if there is a non-null executor 2355 # attached already. The existing executor might have other 2356 # targets, in which case replacing the action list with a 2357 # Mkdir action is a big mistake. 2358 if not hasattr(self, 'executor'): 2359 self.builder = get_MkdirBuilder() 2360 self.get_executor().set_action_list(self.builder.action) 2361 else: 2362 # Prepend MkdirBuilder action to existing action list 2363 l = self.get_executor().action_list 2364 a = get_MkdirBuilder().action 2365 l.insert(0, a) 2366 self.get_executor().set_action_list(l)
2367 2368
2369 - def must_be_same(self, klass):
2370 if klass is Dir: 2371 return 2372 Base.must_be_same(self, klass)
2373
2374 - def _lookup_abs(self, p, klass, create=1):
2375 """ 2376 Fast (?) lookup of a *normalized* absolute path. 2377 2378 This method is intended for use by internal lookups with 2379 already-normalized path data. For general-purpose lookups, 2380 use the FS.Entry(), FS.Dir() or FS.File() methods. 2381 2382 The caller is responsible for making sure we're passed a 2383 normalized absolute path; we merely let Python's dictionary look 2384 up and return the One True Node.FS object for the path. 2385 2386 If a Node for the specified "p" doesn't already exist, and 2387 "create" is specified, the Node may be created after recursive 2388 invocation to find or create the parent directory or directories. 2389 """ 2390 k = _my_normcase(p) 2391 try: 2392 result = self._lookupDict[k] 2393 except KeyError: 2394 if not create: 2395 msg = "No such file or directory: '%s' in '%s' (and create is False)" % (p, str(self)) 2396 raise SCons.Errors.UserError(msg) 2397 # There is no Node for this path name, and we're allowed 2398 # to create it. 2399 dir_name, file_name = p.rsplit('/',1) 2400 dir_node = self._lookup_abs(dir_name, Dir) 2401 result = klass(file_name, dir_node, self.fs) 2402 2403 # Double-check on disk (as configured) that the Node we 2404 # created matches whatever is out there in the real world. 2405 result.diskcheck_match() 2406 2407 self._lookupDict[k] = result 2408 dir_node.entries[_my_normcase(file_name)] = result 2409 dir_node.implicit = None 2410 else: 2411 # There is already a Node for this path name. Allow it to 2412 # complain if we were looking for an inappropriate type. 2413 result.must_be_same(klass) 2414 return result
2415
2416 - def __str__(self):
2417 return self._abspath
2418
2419 - def entry_abspath(self, name):
2420 return self._abspath + name
2421
2422 - def entry_labspath(self, name):
2423 return '/' + name
2424
2425 - def entry_path(self, name):
2426 return self._path + name
2427
2428 - def entry_tpath(self, name):
2429 return self._tpath + name
2430
2431 - def is_under(self, dir):
2432 if self is dir: 2433 return 1 2434 else: 2435 return 0
2436
2437 - def up(self):
2438 return None
2439
2440 - def get_dir(self):
2441 return None
2442
2443 - def src_builder(self):
2444 return _null
2445
2446 -class FileNodeInfo(SCons.Node.NodeInfoBase):
2447 __slots__ = ('csig', 'timestamp', 'size') 2448 current_version_id = 2 2449 2450 field_list = ['csig', 'timestamp', 'size'] 2451 2452 # This should get reset by the FS initialization. 2453 fs = None 2454
2455 - def str_to_node(self, s):
2456 top = self.fs.Top 2457 root = top.root 2458 if do_splitdrive: 2459 drive, s = _my_splitdrive(s) 2460 if drive: 2461 root = self.fs.get_root(drive) 2462 if not os.path.isabs(s): 2463 s = top.get_labspath() + '/' + s 2464 return root._lookup_abs(s, Entry)
2465
2466 - def __getstate__(self):
2467 """ 2468 Return all fields that shall be pickled. Walk the slots in the class 2469 hierarchy and add those to the state dictionary. If a '__dict__' slot is 2470 available, copy all entries to the dictionary. Also include the version 2471 id, which is fixed for all instances of a class. 2472 """ 2473 state = getattr(self, '__dict__', {}).copy() 2474 for obj in type(self).mro(): 2475 for name in getattr(obj,'__slots__',()): 2476 if hasattr(self, name): 2477 state[name] = getattr(self, name) 2478 2479 state['_version_id'] = self.current_version_id 2480 try: 2481 del state['__weakref__'] 2482 except KeyError: 2483 pass 2484 2485 return state
2486
2487 - def __setstate__(self, state):
2488 """ 2489 Restore the attributes from a pickled state. 2490 """ 2491 # TODO check or discard version 2492 del state['_version_id'] 2493 for key, value in state.items(): 2494 if key not in ('__weakref__',): 2495 setattr(self, key, value)
2496
2497 -class FileBuildInfo(SCons.Node.BuildInfoBase):
2498 __slots__ = () 2499 current_version_id = 2 2500
2501 - def convert_to_sconsign(self):
2502 """ 2503 Converts this FileBuildInfo object for writing to a .sconsign file 2504 2505 This replaces each Node in our various dependency lists with its 2506 usual string representation: relative to the top-level SConstruct 2507 directory, or an absolute path if it's outside. 2508 """ 2509 if os_sep_is_slash: 2510 node_to_str = str 2511 else: 2512 def node_to_str(n): 2513 try: 2514 s = n.get_internal_path() 2515 except AttributeError: 2516 s = str(n) 2517 else: 2518 s = s.replace(OS_SEP, '/') 2519 return s
2520 for attr in ['bsources', 'bdepends', 'bimplicit']: 2521 try: 2522 val = getattr(self, attr) 2523 except AttributeError: 2524 pass 2525 else: 2526 setattr(self, attr, list(map(node_to_str, val)))
2527 - def convert_from_sconsign(self, dir, name):
2528 """ 2529 Converts a newly-read FileBuildInfo object for in-SCons use 2530 2531 For normal up-to-date checking, we don't have any conversion to 2532 perform--but we're leaving this method here to make that clear. 2533 """ 2534 pass
2535 - def prepare_dependencies(self):
2536 """ 2537 Prepares a FileBuildInfo object for explaining what changed 2538 2539 The bsources, bdepends and bimplicit lists have all been 2540 stored on disk as paths relative to the top-level SConstruct 2541 directory. Convert the strings to actual Nodes (for use by the 2542 --debug=explain code and --implicit-cache). 2543 """ 2544 attrs = [ 2545 ('bsources', 'bsourcesigs'), 2546 ('bdepends', 'bdependsigs'), 2547 ('bimplicit', 'bimplicitsigs'), 2548 ] 2549 for (nattr, sattr) in attrs: 2550 try: 2551 strings = getattr(self, nattr) 2552 nodeinfos = getattr(self, sattr) 2553 except AttributeError: 2554 continue 2555 if strings is None or nodeinfos is None: 2556 continue 2557 nodes = [] 2558 for s, ni in zip(strings, nodeinfos): 2559 if not isinstance(s, SCons.Node.Node): 2560 s = ni.str_to_node(s) 2561 nodes.append(s) 2562 setattr(self, nattr, nodes)
2563 - def format(self, names=0):
2564 result = [] 2565 bkids = self.bsources + self.bdepends + self.bimplicit 2566 bkidsigs = self.bsourcesigs + self.bdependsigs + self.bimplicitsigs 2567 for bkid, bkidsig in zip(bkids, bkidsigs): 2568 result.append(str(bkid) + ': ' + 2569 ' '.join(bkidsig.format(names=names))) 2570 if not hasattr(self,'bact'): 2571 self.bact = "none" 2572 result.append('%s [%s]' % (self.bactsig, self.bact)) 2573 return '\n'.join(result)
2574
2575 -class File(Base):
2576 """A class for files in a file system. 2577 """ 2578 2579 __slots__ = ['scanner_paths', 2580 'cachedir_csig', 2581 'cachesig', 2582 'repositories', 2583 'srcdir', 2584 'entries', 2585 'searched', 2586 '_sconsign', 2587 'variant_dirs', 2588 'root', 2589 'dirname', 2590 'on_disk_entries', 2591 'sccs_dir', 2592 'rcs_dir', 2593 'released_target_info', 2594 'contentsig'] 2595 2596 NodeInfo = FileNodeInfo 2597 BuildInfo = FileBuildInfo 2598 2599 md5_chunksize = 64 2600
2601 - def diskcheck_match(self):
2602 diskcheck_match(self, self.isdir, 2603 "Directory %s found where file expected.")
2604
2605 - def __init__(self, name, directory, fs):
2606 if SCons.Debug.track_instances: logInstanceCreation(self, 'Node.FS.File') 2607 Base.__init__(self, name, directory, fs) 2608 self._morph()
2609
2610 - def Entry(self, name):
2611 """Create an entry node named 'name' relative to 2612 the directory of this file.""" 2613 return self.dir.Entry(name)
2614
2615 - def Dir(self, name, create=True):
2616 """Create a directory node named 'name' relative to 2617 the directory of this file.""" 2618 return self.dir.Dir(name, create=create)
2619
2620 - def Dirs(self, pathlist):
2621 """Create a list of directories relative to the SConscript 2622 directory of this file.""" 2623 return [self.Dir(p) for p in pathlist]
2624
2625 - def File(self, name):
2626 """Create a file node named 'name' relative to 2627 the directory of this file.""" 2628 return self.dir.File(name)
2629 2630 #def generate_build_dict(self): 2631 # """Return an appropriate dictionary of values for building 2632 # this File.""" 2633 # return {'Dir' : self.Dir, 2634 # 'File' : self.File, 2635 # 'RDirs' : self.RDirs} 2636
2637 - def _morph(self):
2638 """Turn a file system node into a File object.""" 2639 self.scanner_paths = {} 2640 if not hasattr(self, '_local'): 2641 self._local = 0 2642 if not hasattr(self, 'released_target_info'): 2643 self.released_target_info = False 2644 2645 self.store_info = 1 2646 self._func_exists = 4 2647 self._func_get_contents = 3 2648 2649 # Initialize this Node's decider function to decide_source() because 2650 # every file is a source file until it has a Builder attached... 2651 self.changed_since_last_build = 4 2652 2653 # If there was already a Builder set on this entry, then 2654 # we need to make sure we call the target-decider function, 2655 # not the source-decider. Reaching in and doing this by hand 2656 # is a little bogus. We'd prefer to handle this by adding 2657 # an Entry.builder_set() method that disambiguates like the 2658 # other methods, but that starts running into problems with the 2659 # fragile way we initialize Dir Nodes with their Mkdir builders, 2660 # yet still allow them to be overridden by the user. Since it's 2661 # not clear right now how to fix that, stick with what works 2662 # until it becomes clear... 2663 if self.has_builder(): 2664 self.changed_since_last_build = 5
2665
2666 - def scanner_key(self):
2667 return self.get_suffix()
2668
2669 - def get_contents(self):
2671 2672 # This attempts to figure out what the encoding of the text is 2673 # based upon the BOM bytes, and then decodes the contents so that 2674 # it's a valid python string.
2675 - def get_text_contents(self):
2676 contents = self.get_contents() 2677 # The behavior of various decode() methods and functions 2678 # w.r.t. the initial BOM bytes is different for different 2679 # encodings and/or Python versions. ('utf-8' does not strip 2680 # them, but has a 'utf-8-sig' which does; 'utf-16' seems to 2681 # strip them; etc.) Just sidestep all the complication by 2682 # explicitly stripping the BOM before we decode(). 2683 if contents.startswith(codecs.BOM_UTF8): 2684 return contents[len(codecs.BOM_UTF8):].decode('utf-8') 2685 if contents.startswith(codecs.BOM_UTF16_LE): 2686 return contents[len(codecs.BOM_UTF16_LE):].decode('utf-16-le') 2687 if contents.startswith(codecs.BOM_UTF16_BE): 2688 return contents[len(codecs.BOM_UTF16_BE):].decode('utf-16-be') 2689 return contents
2690
2691 - def get_content_hash(self):
2692 """ 2693 Compute and return the MD5 hash for this file. 2694 """ 2695 if not self.rexists(): 2696 return SCons.Util.MD5signature('') 2697 fname = self.rfile().get_abspath() 2698 try: 2699 cs = SCons.Util.MD5filesignature(fname, 2700 chunksize=SCons.Node.FS.File.md5_chunksize*1024) 2701 except EnvironmentError, e: 2702 if not e.filename: 2703 e.filename = fname 2704 raise 2705 return cs
2706 2707 @SCons.Memoize.CountMethodCall
2708 - def get_size(self):
2709 try: 2710 return self._memo['get_size'] 2711 except KeyError: 2712 pass 2713 2714 if self.rexists(): 2715 size = self.rfile().getsize() 2716 else: 2717 size = 0 2718 2719 self._memo['get_size'] = size 2720 2721 return size
2722 2723 @SCons.Memoize.CountMethodCall
2724 - def get_timestamp(self):
2725 try: 2726 return self._memo['get_timestamp'] 2727 except KeyError: 2728 pass 2729 2730 if self.rexists(): 2731 timestamp = self.rfile().getmtime() 2732 else: 2733 timestamp = 0 2734 2735 self._memo['get_timestamp'] = timestamp 2736 2737 return timestamp
2738 2739 convert_copy_attrs = [ 2740 'bsources', 2741 'bimplicit', 2742 'bdepends', 2743 'bact', 2744 'bactsig', 2745 'ninfo', 2746 ] 2747 2748 2749 convert_sig_attrs = [ 2750 'bsourcesigs', 2751 'bimplicitsigs', 2752 'bdependsigs', 2753 ] 2754
2755 - def convert_old_entry(self, old_entry):
2756 # Convert a .sconsign entry from before the Big Signature 2757 # Refactoring, doing what we can to convert its information 2758 # to the new .sconsign entry format. 2759 # 2760 # The old format looked essentially like this: 2761 # 2762 # BuildInfo 2763 # .ninfo (NodeInfo) 2764 # .bsig 2765 # .csig 2766 # .timestamp 2767 # .size 2768 # .bsources 2769 # .bsourcesigs ("signature" list) 2770 # .bdepends 2771 # .bdependsigs ("signature" list) 2772 # .bimplicit 2773 # .bimplicitsigs ("signature" list) 2774 # .bact 2775 # .bactsig 2776 # 2777 # The new format looks like this: 2778 # 2779 # .ninfo (NodeInfo) 2780 # .bsig 2781 # .csig 2782 # .timestamp 2783 # .size 2784 # .binfo (BuildInfo) 2785 # .bsources 2786 # .bsourcesigs (NodeInfo list) 2787 # .bsig 2788 # .csig 2789 # .timestamp 2790 # .size 2791 # .bdepends 2792 # .bdependsigs (NodeInfo list) 2793 # .bsig 2794 # .csig 2795 # .timestamp 2796 # .size 2797 # .bimplicit 2798 # .bimplicitsigs (NodeInfo list) 2799 # .bsig 2800 # .csig 2801 # .timestamp 2802 # .size 2803 # .bact 2804 # .bactsig 2805 # 2806 # The basic idea of the new structure is that a NodeInfo always 2807 # holds all available information about the state of a given Node 2808 # at a certain point in time. The various .b*sigs lists can just 2809 # be a list of pointers to the .ninfo attributes of the different 2810 # dependent nodes, without any copying of information until it's 2811 # time to pickle it for writing out to a .sconsign file. 2812 # 2813 # The complicating issue is that the *old* format only stored one 2814 # "signature" per dependency, based on however the *last* build 2815 # was configured. We don't know from just looking at it whether 2816 # it was a build signature, a content signature, or a timestamp 2817 # "signature". Since we no longer use build signatures, the 2818 # best we can do is look at the length and if it's thirty two, 2819 # assume that it was (or might have been) a content signature. 2820 # If it was actually a build signature, then it will cause a 2821 # rebuild anyway when it doesn't match the new content signature, 2822 # but that's probably the best we can do. 2823 import SCons.SConsign 2824 new_entry = SCons.SConsign.SConsignEntry() 2825 new_entry.binfo = self.new_binfo() 2826 binfo = new_entry.binfo 2827 for attr in self.convert_copy_attrs: 2828 try: 2829 value = getattr(old_entry, attr) 2830 except AttributeError: 2831 continue 2832 setattr(binfo, attr, value) 2833 delattr(old_entry, attr) 2834 for attr in self.convert_sig_attrs: 2835 try: 2836 sig_list = getattr(old_entry, attr) 2837 except AttributeError: 2838 continue 2839 value = [] 2840 for sig in sig_list: 2841 ninfo = self.new_ninfo() 2842 if len(sig) == 32: 2843 ninfo.csig = sig 2844 else: 2845 ninfo.timestamp = sig 2846 value.append(ninfo) 2847 setattr(binfo, attr, value) 2848 delattr(old_entry, attr) 2849 return new_entry
2850 2851 @SCons.Memoize.CountMethodCall
2852 - def get_stored_info(self):
2853 try: 2854 return self._memo['get_stored_info'] 2855 except KeyError: 2856 pass 2857 2858 try: 2859 sconsign_entry = self.dir.sconsign().get_entry(self.name) 2860 except (KeyError, EnvironmentError): 2861 import SCons.SConsign 2862 sconsign_entry = SCons.SConsign.SConsignEntry() 2863 sconsign_entry.binfo = self.new_binfo() 2864 sconsign_entry.