1# Status: this module is ported on demand by however needs something 2# from it. Functionality that is not needed by Python port will 3# be dropped. 4 5# Copyright (C) Vladimir Prus 2002. Permission to copy, use, modify, sell and 6# distribute this software is granted provided this copyright notice appears in 7# all copies. This software is provided "as is" without express or implied 8# warranty, and with no claim as to its suitability for any purpose. 9 10# Performs various path manipulations. Path are always in a 'normilized' 11# representation. In it, a path may be either: 12# 13# - '.', or 14# 15# - ['/'] [ ( '..' '/' )* (token '/')* token ] 16# 17# In plain english, path can be rooted, '..' elements are allowed only 18# at the beginning, and it never ends in slash, except for path consisting 19# of slash only. 20 21import os.path 22from utility import to_seq 23from glob import glob as builtin_glob 24 25from b2.util import bjam_signature 26 27@bjam_signature((["path", "root"],)) 28def root (path, root): 29 """ If 'path' is relative, it is rooted at 'root'. Otherwise, it's unchanged. 30 """ 31 if os.path.isabs (path): 32 return path 33 else: 34 return os.path.join (root, path) 35 36@bjam_signature((["native"],)) 37def make (native): 38 """ Converts the native path into normalized form. 39 """ 40 # TODO: make os selection here. 41 return make_UNIX (native) 42 43def make_UNIX (native): 44 45 # VP: I have no idea now 'native' can be empty here! But it can! 46 assert (native) 47 48 return os.path.normpath (native) 49 50@bjam_signature((["path"],)) 51def native (path): 52 """ Builds a native representation of the path. 53 """ 54 # TODO: make os selection here. 55 return native_UNIX (path) 56 57def native_UNIX (path): 58 return path 59 60 61def pwd (): 62 """ Returns the current working directory. 63 # TODO: is it a good idea to use the current dir? Some use-cases 64 may not allow us to depend on the current dir. 65 """ 66 return make (os.getcwd ()) 67 68def is_rooted (path): 69 """ Tests if a path is rooted. 70 """ 71 return path and path [0] == '/' 72 73 74################################################################### 75# Still to port. 76# Original lines are prefixed with "# " 77# 78# # Copyright (C) Vladimir Prus 2002. Permission to copy, use, modify, sell and 79# # distribute this software is granted provided this copyright notice appears in 80# # all copies. This software is provided "as is" without express or implied 81# # warranty, and with no claim as to its suitability for any purpose. 82# 83# # Performs various path manipulations. Path are always in a 'normilized' 84# # representation. In it, a path may be either: 85# # 86# # - '.', or 87# # 88# # - ['/'] [ ( '..' '/' )* (token '/')* token ] 89# # 90# # In plain english, path can be rooted, '..' elements are allowed only 91# # at the beginning, and it never ends in slash, except for path consisting 92# # of slash only. 93# 94# import modules ; 95# import sequence ; 96# import regex ; 97# import errors : error ; 98# 99# 100# os = [ modules.peek : OS ] ; 101# if [ modules.peek : UNIX ] 102# { 103# local uname = [ modules.peek : JAMUNAME ] ; 104# switch $(uname) 105# { 106# case CYGWIN* : 107# os = CYGWIN ; 108# 109# case * : 110# os = UNIX ; 111# } 112# } 113# 114# # 115# # Tests if a path is rooted. 116# # 117# rule is-rooted ( path ) 118# { 119# return [ MATCH "^(/)" : $(path) ] ; 120# } 121# 122# # 123# # Tests if a path has a parent. 124# # 125# rule has-parent ( path ) 126# { 127# if $(path) != / { 128# return 1 ; 129# } else { 130# return ; 131# } 132# } 133# 134# # 135# # Returns the path without any directory components. 136# # 137# rule basename ( path ) 138# { 139# return [ MATCH "([^/]+)$" : $(path) ] ; 140# } 141# 142# # 143# # Returns parent directory of the path. If no parent exists, error is issued. 144# # 145# rule parent ( path ) 146# { 147# if [ has-parent $(path) ] { 148# 149# if $(path) = . { 150# return .. ; 151# } else { 152# 153# # Strip everything at the end of path up to and including 154# # the last slash 155# local result = [ regex.match "((.*)/)?([^/]+)" : $(path) : 2 3 ] ; 156# 157# # Did we strip what we shouldn't? 158# if $(result[2]) = ".." { 159# return $(path)/.. ; 160# } else { 161# if ! $(result[1]) { 162# if [ is-rooted $(path) ] { 163# result = / ; 164# } else { 165# result = . ; 166# } 167# } 168# return $(result[1]) ; 169# } 170# } 171# } else { 172# error "Path '$(path)' has no parent" ; 173# } 174# } 175# 176# # 177# # Returns path2 such that "[ join path path2 ] = .". 178# # The path may not contain ".." element or be rooted. 179# # 180# rule reverse ( path ) 181# { 182# if $(path) = . 183# { 184# return $(path) ; 185# } 186# else 187# { 188# local tokens = [ regex.split $(path) "/" ] ; 189# local tokens2 ; 190# for local i in $(tokens) { 191# tokens2 += .. ; 192# } 193# return [ sequence.join $(tokens2) : "/" ] ; 194# } 195# } 196def reverse(path): 197 """Returns path2 such that `os.path.join(path, path2) == '.'`. 198 `path` may not contain '..' or be rooted. 199 200 Args: 201 path (str): the path to reverse 202 203 Returns: 204 the string of the reversed path 205 206 Example: 207 208 >>> p1 = 'path/to/somewhere' 209 >>> p2 = reverse('path/to/somewhere') 210 >>> p2 211 '../../..' 212 >>> os.path.normpath(os.path.join(p1, p2)) 213 '.' 214 """ 215 if is_rooted(path) or '..' in path: 216 from b2.manager import get_manager 217 get_manager().errors()( 218 'reverse(path): path is either rooted or contains ".." in the path') 219 if path == '.': 220 return path 221 path = os.path.normpath(path) 222 # os.sep.join() is being used over os.path.join() due 223 # to an extra '..' that is created by os.path.join() 224 return os.sep.join('..' for t in path.split(os.sep)) 225# # 226# # Auxillary rule: does all the semantic of 'join', except for error cheching. 227# # The error checking is separated because this rule is recursive, and I don't 228# # like the idea of checking the same input over and over. 229# # 230# local rule join-imp ( elements + ) 231# { 232# return [ NORMALIZE_PATH $(elements:J="/") ] ; 233# } 234# 235# # 236# # Contanenates the passed path elements. Generates an error if 237# # any element other than the first one is rooted. 238# # 239# rule join ( elements + ) 240# { 241# if ! $(elements[2]) 242# { 243# return $(elements[1]) ; 244# } 245# else 246# { 247# for local e in $(elements[2-]) 248# { 249# if [ is-rooted $(e) ] 250# { 251# error only first element may be rooted ; 252# } 253# } 254# return [ join-imp $(elements) ] ; 255# } 256# } 257 258 259def glob (dirs, patterns): 260 """ Returns the list of files matching the given pattern in the 261 specified directory. Both directories and patterns are 262 supplied as portable paths. Each pattern should be non-absolute 263 path, and can't contain "." or ".." elements. Each slash separated 264 element of pattern can contain the following special characters: 265 - '?', which match any character 266 - '*', which matches arbitrary number of characters. 267 A file $(d)/e1/e2/e3 (where 'd' is in $(dirs)) matches pattern p1/p2/p3 268 if and only if e1 matches p1, e2 matches p2 and so on. 269 270 For example: 271 [ glob . : *.cpp ] 272 [ glob . : */build/Jamfile ] 273 """ 274# { 275# local result ; 276# if $(patterns:D) 277# { 278# # When a pattern has a directory element, we first glob for 279# # directory, and then glob for file name is the found directories. 280# for local p in $(patterns) 281# { 282# # First glob for directory part. 283# local globbed-dirs = [ glob $(dirs) : $(p:D) ] ; 284# result += [ glob $(globbed-dirs) : $(p:D="") ] ; 285# } 286# } 287# else 288# { 289# # When a pattern has not directory, we glob directly. 290# # Take care of special ".." value. The "GLOB" rule simply ignores 291# # the ".." element (and ".") element in directory listings. This is 292# # needed so that 293# # 294# # [ glob libs/*/Jamfile ] 295# # 296# # don't return 297# # 298# # libs/../Jamfile (which is the same as ./Jamfile) 299# # 300# # On the other hand, when ".." is explicitly present in the pattern 301# # we need to return it. 302# # 303# for local dir in $(dirs) 304# { 305# for local p in $(patterns) 306# { 307# if $(p) != ".." 308# { 309# result += [ sequence.transform make 310# : [ GLOB [ native $(dir) ] : $(p) ] ] ; 311# } 312# else 313# { 314# result += [ path.join $(dir) .. ] ; 315# } 316# } 317# } 318# } 319# return $(result) ; 320# } 321# 322 323# TODO: (PF) I replaced the code above by this. I think it should work but needs to be tested. 324 result = [] 325 dirs = to_seq (dirs) 326 patterns = to_seq (patterns) 327 328 splitdirs = [] 329 for dir in dirs: 330 splitdirs += dir.split (os.pathsep) 331 332 for dir in splitdirs: 333 for pattern in patterns: 334 p = os.path.join (dir, pattern) 335 import glob 336 result.extend (glob.glob (p)) 337 return result 338 339# 340# Find out the absolute name of path and returns the list of all the parents, 341# starting with the immediate one. Parents are returned as relative names. 342# If 'upper_limit' is specified, directories above it will be pruned. 343# 344def all_parents(path, upper_limit=None, cwd=None): 345 346 if not cwd: 347 cwd = os.getcwd() 348 349 path_abs = os.path.join(cwd, path) 350 351 if upper_limit: 352 upper_limit = os.path.join(cwd, upper_limit) 353 354 result = [] 355 while path_abs and path_abs != upper_limit: 356 (head, tail) = os.path.split(path) 357 path = os.path.join(path, "..") 358 result.append(path) 359 path_abs = head 360 361 if upper_limit and path_abs != upper_limit: 362 raise BaseException("'%s' is not a prefix of '%s'" % (upper_limit, path)) 363 364 return result 365 366# Search for 'pattern' in parent directories of 'dir', up till and including 367# 'upper_limit', if it is specified, or till the filesystem root otherwise. 368# 369def glob_in_parents(dir, patterns, upper_limit=None): 370 371 result = [] 372 parent_dirs = all_parents(dir, upper_limit) 373 374 for p in parent_dirs: 375 result = glob(p, patterns) 376 if result: break 377 378 return result 379 380# 381# # 382# # Assuming 'child' is a subdirectory of 'parent', return the relative 383# # path from 'parent' to 'child' 384# # 385# rule relative ( child parent ) 386# { 387# if $(parent) = "." 388# { 389# return $(child) ; 390# } 391# else 392# { 393# local split1 = [ regex.split $(parent) / ] ; 394# local split2 = [ regex.split $(child) / ] ; 395# 396# while $(split1) 397# { 398# if $(split1[1]) = $(split2[1]) 399# { 400# split1 = $(split1[2-]) ; 401# split2 = $(split2[2-]) ; 402# } 403# else 404# { 405# errors.error $(child) is not a subdir of $(parent) ; 406# } 407# } 408# return [ join $(split2) ] ; 409# } 410# } 411# 412# # Returns the minimal path to path2 that is relative path1. 413# # 414# rule relative-to ( path1 path2 ) 415# { 416# local root_1 = [ regex.split [ reverse $(path1) ] / ] ; 417# local split1 = [ regex.split $(path1) / ] ; 418# local split2 = [ regex.split $(path2) / ] ; 419# 420# while $(split1) && $(root_1) 421# { 422# if $(split1[1]) = $(split2[1]) 423# { 424# root_1 = $(root_1[2-]) ; 425# split1 = $(split1[2-]) ; 426# split2 = $(split2[2-]) ; 427# } 428# else 429# { 430# split1 = ; 431# } 432# } 433# return [ join . $(root_1) $(split2) ] ; 434# } 435 436# Returns the list of paths which are used by the operating system 437# for looking up programs 438def programs_path (): 439 raw = [] 440 names = ['PATH', 'Path', 'path'] 441 442 for name in names: 443 raw.append(os.environ.get (name, '')) 444 445 result = [] 446 for elem in raw: 447 if elem: 448 for p in elem.split(os.path.pathsep): 449 # it's possible that the user's Path has 450 # double path separators, thus it is possible 451 # for p to be an empty string. 452 if p: 453 result.append(make(p)) 454 455 return result 456 457# rule make-NT ( native ) 458# { 459# local tokens = [ regex.split $(native) "[/\\]" ] ; 460# local result ; 461# 462# # Handle paths ending with slashes 463# if $(tokens[-1]) = "" 464# { 465# tokens = $(tokens[1--2]) ; # discard the empty element 466# } 467# 468# result = [ path.join $(tokens) ] ; 469# 470# if [ regex.match "(^.:)" : $(native) ] 471# { 472# result = /$(result) ; 473# } 474# 475# if $(native) = "" 476# { 477# result = "." ; 478# } 479# 480# return $(result) ; 481# } 482# 483# rule native-NT ( path ) 484# { 485# local result = [ MATCH "^/?(.*)" : $(path) ] ; 486# result = [ sequence.join [ regex.split $(result) "/" ] : "\\" ] ; 487# return $(result) ; 488# } 489# 490# rule make-CYGWIN ( path ) 491# { 492# return [ make-NT $(path) ] ; 493# } 494# 495# rule native-CYGWIN ( path ) 496# { 497# local result = $(path) ; 498# if [ regex.match "(^/.:)" : $(path) ] # win absolute 499# { 500# result = [ MATCH "^/?(.*)" : $(path) ] ; # remove leading '/' 501# } 502# return [ native-UNIX $(result) ] ; 503# } 504# 505# # 506# # split-VMS: splits input native path into 507# # device dir file (each part is optional), 508# # example: 509# # 510# # dev:[dir]file.c => dev: [dir] file.c 511# # 512# rule split-path-VMS ( native ) 513# { 514# local matches = [ MATCH ([a-zA-Z0-9_-]+:)?(\\[[^\]]*\\])?(.*)?$ : $(native) ] ; 515# local device = $(matches[1]) ; 516# local dir = $(matches[2]) ; 517# local file = $(matches[3]) ; 518# 519# return $(device) $(dir) $(file) ; 520# } 521# 522# # 523# # Converts a native VMS path into a portable path spec. 524# # 525# # Does not handle current-device absolute paths such 526# # as "[dir]File.c" as it is not clear how to represent 527# # them in the portable path notation. 528# # 529# # Adds a trailing dot (".") to the file part if no extension 530# # is present (helps when converting it back into native path). 531# # 532# rule make-VMS ( native ) 533# { 534# if [ MATCH ^(\\[[a-zA-Z0-9]) : $(native) ] 535# { 536# errors.error "Can't handle default-device absolute paths: " $(native) ; 537# } 538# 539# local parts = [ split-path-VMS $(native) ] ; 540# local device = $(parts[1]) ; 541# local dir = $(parts[2]) ; 542# local file = $(parts[3]) ; 543# local elems ; 544# 545# if $(device) 546# { 547# # 548# # rooted 549# # 550# elems = /$(device) ; 551# } 552# 553# if $(dir) = "[]" 554# { 555# # 556# # Special case: current directory 557# # 558# elems = $(elems) "." ; 559# } 560# else if $(dir) 561# { 562# dir = [ regex.replace $(dir) "\\[|\\]" "" ] ; 563# local dir_parts = [ regex.split $(dir) \\. ] ; 564# 565# if $(dir_parts[1]) = "" 566# { 567# # 568# # Relative path 569# # 570# dir_parts = $(dir_parts[2--1]) ; 571# } 572# 573# # 574# # replace "parent-directory" parts (- => ..) 575# # 576# dir_parts = [ regex.replace-list $(dir_parts) : - : .. ] ; 577# 578# elems = $(elems) $(dir_parts) ; 579# } 580# 581# if $(file) 582# { 583# if ! [ MATCH (\\.) : $(file) ] 584# { 585# # 586# # Always add "." to end of non-extension file 587# # 588# file = $(file). ; 589# } 590# elems = $(elems) $(file) ; 591# } 592# 593# local portable = [ path.join $(elems) ] ; 594# 595# return $(portable) ; 596# } 597# 598# # 599# # Converts a portable path spec into a native VMS path. 600# # 601# # Relies on having at least one dot (".") included in the file 602# # name to be able to differentiate it ftom the directory part. 603# # 604# rule native-VMS ( path ) 605# { 606# local device = "" ; 607# local dir = $(path) ; 608# local file = "" ; 609# local native ; 610# local split ; 611# 612# # 613# # Has device ? 614# # 615# if [ is-rooted $(dir) ] 616# { 617# split = [ MATCH ^/([^:]+:)/?(.*) : $(dir) ] ; 618# device = $(split[1]) ; 619# dir = $(split[2]) ; 620# } 621# 622# # 623# # Has file ? 624# # 625# # This is no exact science, just guess work: 626# # 627# # If the last part of the current path spec 628# # includes some chars, followed by a dot, 629# # optionally followed by more chars - 630# # then it is a file (keep your fingers crossed). 631# # 632# split = [ regex.split $(dir) / ] ; 633# local maybe_file = $(split[-1]) ; 634# 635# if [ MATCH ^([^.]+\\..*) : $(maybe_file) ] 636# { 637# file = $(maybe_file) ; 638# dir = [ sequence.join $(split[1--2]) : / ] ; 639# } 640# 641# # 642# # Has dir spec ? 643# # 644# if $(dir) = "." 645# { 646# dir = "[]" ; 647# } 648# else if $(dir) 649# { 650# dir = [ regex.replace $(dir) \\.\\. - ] ; 651# dir = [ regex.replace $(dir) / . ] ; 652# 653# if $(device) = "" 654# { 655# # 656# # Relative directory 657# # 658# dir = "."$(dir) ; 659# } 660# dir = "["$(dir)"]" ; 661# } 662# 663# native = [ sequence.join $(device) $(dir) $(file) ] ; 664# 665# return $(native) ; 666# } 667# 668# 669# rule __test__ ( ) { 670# 671# import assert ; 672# import errors : try catch ; 673# 674# assert.true is-rooted "/" ; 675# assert.true is-rooted "/foo" ; 676# assert.true is-rooted "/foo/bar" ; 677# assert.result : is-rooted "." ; 678# assert.result : is-rooted "foo" ; 679# assert.result : is-rooted "foo/bar" ; 680# 681# assert.true has-parent "foo" ; 682# assert.true has-parent "foo/bar" ; 683# assert.true has-parent "." ; 684# assert.result : has-parent "/" ; 685# 686# assert.result "." : basename "." ; 687# assert.result ".." : basename ".." ; 688# assert.result "foo" : basename "foo" ; 689# assert.result "foo" : basename "bar/foo" ; 690# assert.result "foo" : basename "gaz/bar/foo" ; 691# assert.result "foo" : basename "/gaz/bar/foo" ; 692# 693# assert.result "." : parent "foo" ; 694# assert.result "/" : parent "/foo" ; 695# assert.result "foo/bar" : parent "foo/bar/giz" ; 696# assert.result ".." : parent "." ; 697# assert.result ".." : parent "../foo" ; 698# assert.result "../../foo" : parent "../../foo/bar" ; 699# 700# 701# assert.result "." : reverse "." ; 702# assert.result ".." : reverse "foo" ; 703# assert.result "../../.." : reverse "foo/bar/giz" ; 704# 705# assert.result "foo" : join "foo" ; 706# assert.result "/foo" : join "/" "foo" ; 707# assert.result "foo/bar" : join "foo" "bar" ; 708# assert.result "foo/bar" : join "foo/giz" "../bar" ; 709# assert.result "foo/giz" : join "foo/bar/baz" "../../giz" ; 710# assert.result ".." : join "." ".." ; 711# assert.result ".." : join "foo" "../.." ; 712# assert.result "../.." : join "../foo" "../.." ; 713# assert.result "/foo" : join "/bar" "../foo" ; 714# assert.result "foo/giz" : join "foo/giz" "." ; 715# assert.result "." : join lib2 ".." ; 716# assert.result "/" : join "/a" ".." ; 717# 718# assert.result /a/b : join /a/b/c .. ; 719# 720# assert.result "foo/bar/giz" : join "foo" "bar" "giz" ; 721# assert.result "giz" : join "foo" ".." "giz" ; 722# assert.result "foo/giz" : join "foo" "." "giz" ; 723# 724# try ; 725# { 726# join "a" "/b" ; 727# } 728# catch only first element may be rooted ; 729# 730# local CWD = "/home/ghost/build" ; 731# assert.result : all-parents . : . : $(CWD) ; 732# assert.result . .. ../.. ../../.. : all-parents "Jamfile" : "" : $(CWD) ; 733# assert.result foo . .. ../.. ../../.. : all-parents "foo/Jamfile" : "" : $(CWD) ; 734# assert.result ../Work .. ../.. ../../.. : all-parents "../Work/Jamfile" : "" : $(CWD) ; 735# 736# local CWD = "/home/ghost" ; 737# assert.result . .. : all-parents "Jamfile" : "/home" : $(CWD) ; 738# assert.result . : all-parents "Jamfile" : "/home/ghost" : $(CWD) ; 739# 740# assert.result "c/d" : relative "a/b/c/d" "a/b" ; 741# assert.result "foo" : relative "foo" "." ; 742# 743# local save-os = [ modules.peek path : os ] ; 744# modules.poke path : os : NT ; 745# 746# assert.result "foo/bar/giz" : make "foo/bar/giz" ; 747# assert.result "foo/bar/giz" : make "foo\\bar\\giz" ; 748# assert.result "foo" : make "foo/." ; 749# assert.result "foo" : make "foo/bar/.." ; 750# assert.result "/D:/My Documents" : make "D:\\My Documents" ; 751# assert.result "/c:/boost/tools/build/new/project.jam" : make "c:\\boost\\tools\\build\\test\\..\\new\\project.jam" ; 752# 753# assert.result "foo\\bar\\giz" : native "foo/bar/giz" ; 754# assert.result "foo" : native "foo" ; 755# assert.result "D:\\My Documents\\Work" : native "/D:/My Documents/Work" ; 756# 757# modules.poke path : os : UNIX ; 758# 759# assert.result "foo/bar/giz" : make "foo/bar/giz" ; 760# assert.result "/sub1" : make "/sub1/." ; 761# assert.result "/sub1" : make "/sub1/sub2/.." ; 762# assert.result "sub1" : make "sub1/." ; 763# assert.result "sub1" : make "sub1/sub2/.." ; 764# assert.result "/foo/bar" : native "/foo/bar" ; 765# 766# modules.poke path : os : VMS ; 767# 768# # 769# # Don't really need to poke os before these 770# # 771# assert.result "disk:" "[dir]" "file" : split-path-VMS "disk:[dir]file" ; 772# assert.result "disk:" "[dir]" "" : split-path-VMS "disk:[dir]" ; 773# assert.result "disk:" "" "" : split-path-VMS "disk:" ; 774# assert.result "disk:" "" "file" : split-path-VMS "disk:file" ; 775# assert.result "" "[dir]" "file" : split-path-VMS "[dir]file" ; 776# assert.result "" "[dir]" "" : split-path-VMS "[dir]" ; 777# assert.result "" "" "file" : split-path-VMS "file" ; 778# assert.result "" "" "" : split-path-VMS "" ; 779# 780# # 781# # Special case: current directory 782# # 783# assert.result "" "[]" "" : split-path-VMS "[]" ; 784# assert.result "disk:" "[]" "" : split-path-VMS "disk:[]" ; 785# assert.result "" "[]" "file" : split-path-VMS "[]file" ; 786# assert.result "disk:" "[]" "file" : split-path-VMS "disk:[]file" ; 787# 788# # 789# # Make portable paths 790# # 791# assert.result "/disk:" : make "disk:" ; 792# assert.result "foo/bar/giz" : make "[.foo.bar.giz]" ; 793# assert.result "foo" : make "[.foo]" ; 794# assert.result "foo" : make "[.foo.bar.-]" ; 795# assert.result ".." : make "[.-]" ; 796# assert.result ".." : make "[-]" ; 797# assert.result "." : make "[]" ; 798# assert.result "giz.h" : make "giz.h" ; 799# assert.result "foo/bar/giz.h" : make "[.foo.bar]giz.h" ; 800# assert.result "/disk:/my_docs" : make "disk:[my_docs]" ; 801# assert.result "/disk:/boost/tools/build/new/project.jam" : make "disk:[boost.tools.build.test.-.new]project.jam" ; 802# 803# # 804# # Special case (adds '.' to end of file w/o extension to 805# # disambiguate from directory in portable path spec). 806# # 807# assert.result "Jamfile." : make "Jamfile" ; 808# assert.result "dir/Jamfile." : make "[.dir]Jamfile" ; 809# assert.result "/disk:/dir/Jamfile." : make "disk:[dir]Jamfile" ; 810# 811# # 812# # Make native paths 813# # 814# assert.result "disk:" : native "/disk:" ; 815# assert.result "[.foo.bar.giz]" : native "foo/bar/giz" ; 816# assert.result "[.foo]" : native "foo" ; 817# assert.result "[.-]" : native ".." ; 818# assert.result "[.foo.-]" : native "foo/.." ; 819# assert.result "[]" : native "." ; 820# assert.result "disk:[my_docs.work]" : native "/disk:/my_docs/work" ; 821# assert.result "giz.h" : native "giz.h" ; 822# assert.result "disk:Jamfile." : native "/disk:Jamfile." ; 823# assert.result "disk:[my_docs.work]Jamfile." : native "/disk:/my_docs/work/Jamfile." ; 824# 825# modules.poke path : os : $(save-os) ; 826# 827# } 828 829# 830 831 832#def glob(dir, patterns): 833# result = [] 834# for pattern in patterns: 835# result.extend(builtin_glob(os.path.join(dir, pattern))) 836# return result 837 838def glob(dirs, patterns, exclude_patterns=None): 839 """Returns the list of files matching the given pattern in the 840 specified directory. Both directories and patterns are 841 supplied as portable paths. Each pattern should be non-absolute 842 path, and can't contain '.' or '..' elements. Each slash separated 843 element of pattern can contain the following special characters: 844 - '?', which match any character 845 - '*', which matches arbitrary number of characters. 846 A file $(d)/e1/e2/e3 (where 'd' is in $(dirs)) matches pattern p1/p2/p3 847 if and only if e1 matches p1, e2 matches p2 and so on. 848 For example: 849 [ glob . : *.cpp ] 850 [ glob . : */build/Jamfile ] 851 """ 852 853 assert(isinstance(patterns, list)) 854 assert(isinstance(dirs, list)) 855 856 if not exclude_patterns: 857 exclude_patterns = [] 858 else: 859 assert(isinstance(exclude_patterns, list)) 860 861 real_patterns = [os.path.join(d, p) for p in patterns for d in dirs] 862 real_exclude_patterns = [os.path.join(d, p) for p in exclude_patterns 863 for d in dirs] 864 865 inc = [os.path.normpath(name) for p in real_patterns 866 for name in builtin_glob(p)] 867 exc = [os.path.normpath(name) for p in real_exclude_patterns 868 for name in builtin_glob(p)] 869 return [x for x in inc if x not in exc] 870 871def glob_tree(roots, patterns, exclude_patterns=None): 872 """Recursive version of GLOB. Builds the glob of files while 873 also searching in the subdirectories of the given roots. An 874 optional set of exclusion patterns will filter out the 875 matching entries from the result. The exclusions also apply 876 to the subdirectory scanning, such that directories that 877 match the exclusion patterns will not be searched.""" 878 879 if not exclude_patterns: 880 exclude_patterns = [] 881 882 result = glob(roots, patterns, exclude_patterns) 883 subdirs = [s for s in glob(roots, ["*"]) if s != "." and s != ".." and os.path.isdir(s)] 884 if subdirs: 885 result.extend(glob_tree(subdirs, patterns, exclude_patterns)) 886 887 return result 888 889def glob_in_parents(dir, patterns, upper_limit=None): 890 """Recursive version of GLOB which glob sall parent directories 891 of dir until the first match is found. Returns an empty result if no match 892 is found""" 893 894 assert(isinstance(dir, str)) 895 assert(isinstance(patterns, list)) 896 897 result = [] 898 899 absolute_dir = os.path.join(os.getcwd(), dir) 900 absolute_dir = os.path.normpath(absolute_dir) 901 while absolute_dir: 902 new_dir = os.path.split(absolute_dir)[0] 903 if new_dir == absolute_dir: 904 break 905 result = glob([new_dir], patterns) 906 if result: 907 break 908 absolute_dir = new_dir 909 910 return result 911 912 913# The relpath functionality is written by 914# Cimarron Taylor 915def split(p, rest=[]): 916 (h,t) = os.path.split(p) 917 if len(h) < 1: return [t]+rest 918 if len(t) < 1: return [h]+rest 919 return split(h,[t]+rest) 920 921def commonpath(l1, l2, common=[]): 922 if len(l1) < 1: return (common, l1, l2) 923 if len(l2) < 1: return (common, l1, l2) 924 if l1[0] != l2[0]: return (common, l1, l2) 925 return commonpath(l1[1:], l2[1:], common+[l1[0]]) 926 927def relpath(p1, p2): 928 (common,l1,l2) = commonpath(split(p1), split(p2)) 929 p = [] 930 if len(l1) > 0: 931 p = [ '../' * len(l1) ] 932 p = p + l2 933 if p: 934 return os.path.join( *p ) 935 else: 936 return "." 937