Merge remote branch 'upstream/master'

Conflicts:
	Jamroot
	bjam
	decoder/Jamfile
	decoder/cdec.cc
	dpmert/Jamfile
	jam-files/sanity.jam
	klm/lm/Jamfile
	klm/util/Jamfile
	mira/Jamfile

1 files changed, 0 insertions, 934 deletions

diff --git a/jam-files/boost-build/util/path.jam b/jam-files/boost-build/util/path.jam
deleted file mode 100644
index ea26b816..00000000
--- a/jam-files/boost-build/util/path.jam
+++ /dev/null
@@ -1,934 +0,0 @@
-# Copyright Vladimir Prus 2002-2006.
-# Copyright Dave Abrahams 2003-2004.
-# Copyright Rene Rivera 2003-2006.
-#
-# Distributed under the Boost Software License, Version 1.0.
-#    (See accompanying file LICENSE_1_0.txt or copy at
-#          http://www.boost.org/LICENSE_1_0.txt)
-
-# Performs various path manipulations. Paths are always in a 'normalized'
-# representation. In it, a path may be either:
-#
-#     - '.', or
-#
-#     - ['/'] [ ( '..' '/' )* (token '/')* token ]
-#
-# In plain english, path can be rooted, '..' elements are allowed only at the
-# beginning, and it never ends in slash, except for path consisting of slash
-# only.
-
-import errors ;
-import modules ;
-import regex ;
-import sequence ;
-import set ;
-import version ;
-
-
-os = [ modules.peek : OS ] ;
-if [ modules.peek : UNIX ]
-{
-    local uname = [ modules.peek : JAMUNAME ] ;
-    switch $(uname)
-    {
-        case CYGWIN* : os = CYGWIN ;
-        case *       : os = UNIX ;
-    }
-}
-
-
-# Converts the native path into normalized form.
-#
-rule make ( native )
-{
-    return [ make-$(os) $(native) ] ;
-}
-
-
-# Builds native representation of the path.
-#
-rule native ( path )
-{
-    return [ native-$(os) $(path) ] ;
-}
-
-
-# Tests if a path is rooted.
-#
-rule is-rooted ( path )
-{
-    return [ MATCH "^(/)" : $(path) ] ;
-}
-
-
-# Tests if a path has a parent.
-#
-rule has-parent ( path )
-{
-    if $(path) != /
-    {
-        return 1 ;
-    }
-    else
-    {
-        return ;
-    }
-}
-
-
-# Returns the path without any directory components.
-#
-rule basename ( path )
-{
-    return [ MATCH "([^/]+)$" : $(path) ] ;
-}
-
-
-# Returns parent directory of the path. If no parent exists, error is issued.
-#
-rule parent ( path )
-{
-    if [ has-parent $(path) ]
-    {
-        if $(path) = .
-        {
-            return .. ;
-        }
-        else
-        {
-            # Strip everything at the end of path up to and including the last
-            # slash.
-            local result = [ regex.match "((.*)/)?([^/]+)" : $(path) : 2 3 ] ;
-
-            # Did we strip what we shouldn't?
-            if $(result[2]) = ".."
-            {
-                return $(path)/.. ;
-            }
-            else
-            {
-                if ! $(result[1])
-                {
-                    if [ is-rooted $(path) ]
-                    {
-                        result = / ;
-                    }
-                    else
-                    {
-                        result = . ;
-                    }
-                }
-                return $(result[1]) ;
-            }
-        }
-    }
-    else
-    {
-        errors.error "Path '$(path)' has no parent" ;
-    }
-}
-
-
-# Returns path2 such that "[ join path path2 ] = .". The path may not contain
-# ".." element or be rooted.
-#
-rule reverse ( path )
-{
-    if $(path) = .
-    {
-        return $(path) ;
-    }
-    else
-    {
-        local tokens = [ regex.split $(path) "/" ] ;
-        local tokens2 ;
-        for local i in $(tokens)
-        {
-            tokens2 += .. ;
-        }
-        return [ sequence.join $(tokens2) : "/" ] ;
-    }
-}
-
-
-# Concatenates the passed path elements. Generates an error if any element other
-# than the first one is rooted. Skips any empty or undefined path elements.
-#
-rule join ( elements + )
-{
-    if ! $(elements[2-])
-    {
-        return $(elements[1]) ;
-    }
-    else
-    {
-        for local e in $(elements[2-])
-        {
-            if [ is-rooted $(e) ]
-            {
-                errors.error only the first element may be rooted ;
-            }
-        }
-        if [ version.check-jam-version 3 1 17 ]
-        {
-            return [ NORMALIZE_PATH "$(elements)" ] ;
-        }
-        else
-        {
-            # Boost Jam prior to version 3.1.17 had problems with its
-            # NORMALIZE_PATH rule in case you passed it a leading backslash
-            # instead of a slash, in some cases when you sent it an empty
-            # initial path element and possibly some others. At least some of
-            # those cases were being hit and relied upon when calling this rule
-            # from the path.make-NT rule.
-            if ! $(elements[1]) && $(elements[2])
-            {
-                return [ NORMALIZE_PATH "/" "$(elements[2-])" ] ;
-            }
-            else
-            {
-                return [ NORMALIZE_PATH "$(elements)" ] ;
-            }
-        }
-    }
-}
-
-
-# If 'path' is relative, it is rooted at 'root'. Otherwise, it is unchanged.
-#
-rule root ( path root )
-{
-    if [ is-rooted $(path) ]
-    {
-        return $(path) ;
-    }
-    else
-    {
-        return [ join $(root) $(path) ] ;
-    }
-}
-
-
-# Returns the current working directory.
-#
-rule pwd ( )
-{
-    if ! $(.pwd)
-    {
-        .pwd = [ make [ PWD ] ] ;
-    }
-    return $(.pwd) ;
-}
-
-
-# Returns the list of files matching the given pattern in the specified
-# directory. Both directories and patterns are supplied as portable paths. Each
-# pattern should be non-absolute path, and can't contain "." or ".." elements.
-# Each slash separated element of pattern can contain the following special
-# characters:
-#   - '?', which match any character
-#   - '*', which matches arbitrary number of characters.
-# A file $(d)/e1/e2/e3 (where 'd' is in $(dirs)) matches pattern p1/p2/p3 if and
-# only if e1 matches p1, e2 matches p2 and so on.
-#
-# For example:
-#   [ glob . : *.cpp ]
-#   [ glob . : */build/Jamfile ]
-#
-rule glob ( dirs * : patterns + : exclude-patterns * )
-{
-    local result ;
-    local real-patterns ;
-    local real-exclude-patterns ;
-    for local d in $(dirs)
-    {
-        for local p in $(patterns)
-        {
-            local pattern = [ path.root $(p) $(d) ] ;
-            real-patterns += [ path.native $(pattern) ] ;
-        }
-
-        for local p in $(exclude-patterns)
-        {
-            local pattern = [ path.root $(p) $(d) ] ;
-            real-exclude-patterns += [ path.native $(pattern) ] ;
-        }
-    }
-
-    local inc = [ GLOB-RECURSIVELY $(real-patterns) ] ;
-    inc = [ sequence.transform NORMALIZE_PATH : $(inc) ] ;
-    local exc = [ GLOB-RECURSIVELY $(real-exclude-patterns) ] ;
-    exc = [ sequence.transform NORMALIZE_PATH : $(exc) ] ;
-
-    return [ sequence.transform path.make : [ set.difference $(inc) : $(exc) ] ]
-        ;
-}
-
-
-# Recursive version of GLOB. Builds the glob of files while also searching in
-# the subdirectories of the given roots. An optional set of exclusion patterns
-# will filter out the matching entries from the result. The exclusions also
-# apply to the subdirectory scanning, such that directories that match the
-# exclusion patterns will not be searched.
-#
-rule glob-tree ( roots * : patterns + : exclude-patterns * )
-{
-    return [ sequence.transform path.make : [ .glob-tree [ sequence.transform
-        path.native : $(roots) ] : $(patterns) : $(exclude-patterns) ] ] ;
-}
-
-
-local rule .glob-tree ( roots * : patterns * : exclude-patterns * )
-{
-    local excluded ;
-    if $(exclude-patterns)
-    {
-        excluded = [ GLOB $(roots) : $(exclude-patterns) ] ;
-    }
-    local result = [ set.difference [ GLOB $(roots) : $(patterns) ] :
-        $(excluded) ] ;
-    local subdirs ;
-    for local d in [ set.difference [ GLOB $(roots) : * ] : $(excluded) ]
-    {
-        if ! ( $(d:D=) in . .. ) && ! [ CHECK_IF_FILE $(d) ]
-        {
-            subdirs += $(d) ;
-        }
-    }
-    if $(subdirs)
-    {
-        result += [ .glob-tree $(subdirs) : $(patterns) : $(exclude-patterns) ]
-            ;
-    }
-    return $(result) ;
-}
-
-
-# Returns true is the specified file exists.
-#
-rule exists ( file )
-{
-    return [ path.glob $(file:D) : $(file:D=) ] ;
-}
-NATIVE_RULE path : exists ;
-
-
-# Find out the absolute name of path and returns the list of all the parents,
-# starting with the immediate one. Parents are returned as relative names. If
-# 'upper_limit' is specified, directories above it will be pruned.
-#
-rule all-parents ( path : upper_limit ? : cwd ? )
-{
-    cwd ?= [ pwd ] ;
-    local path_ele = [ regex.split [ root $(path) $(cwd) ] "/" ] ;
-
-    if ! $(upper_limit)
-    {
-        upper_limit = / ;
-    }
-    local upper_ele = [ regex.split [ root $(upper_limit) $(cwd) ] "/" ] ;
-
-    # Leave only elements in 'path_ele' below 'upper_ele'.
-    while $(path_ele) && ( $(upper_ele[1]) = $(path_ele[1]) )
-    {
-        upper_ele = $(upper_ele[2-]) ;
-        path_ele = $(path_ele[2-]) ;
-    }
-
-    # Have all upper elements been removed ?
-    if $(upper_ele)
-    {
-        errors.error "$(upper_limit) is not prefix of $(path)" ;
-    }
-    
-    # Create the relative paths to parents, number of elements in 'path_ele'.
-    local result ;
-    for local i in $(path_ele)
-    {
-        path = [ parent $(path) ] ;
-        result += $(path) ;
-    }
-    return $(result) ;
-}
-
-
-# Search for 'pattern' in parent directories of 'dir', up till and including
-# 'upper_limit', if it is specified, or till the filesystem root otherwise.
-#
-rule glob-in-parents ( dir : patterns + : upper-limit ? )
-{
-    local result ;
-    local parent-dirs = [ all-parents $(dir) : $(upper-limit) ] ;
-
-    while $(parent-dirs) && ! $(result)
-    {
-        result = [ glob $(parent-dirs[1]) : $(patterns) ] ;
-        parent-dirs = $(parent-dirs[2-]) ;
-    }
-    return $(result) ;
-}
-
-
-# Assuming 'child' is a subdirectory of 'parent', return the relative path from
-# 'parent' to 'child'.
-#
-rule relative ( child parent : no-error ? )
-{
-    local not-a-child ;
-    if $(parent) = "."
-    {
-        return $(child) ;
-    }
-    else
-    {
-        local split1 = [ regex.split $(parent) / ] ;
-        local split2 = [ regex.split $(child) / ] ;
-
-        while $(split1)
-        {
-            if $(split1[1]) = $(split2[1])
-            {
-                split1 = $(split1[2-]) ;
-                split2 = $(split2[2-]) ;
-            }
-            else
-            {
-                not-a-child = true ;
-                split1 = ;
-            }
-        }
-        if $(split2)
-        {
-            if $(not-a-child)
-            {
-                if $(no-error)
-                {
-                    return not-a-child ;
-                }
-                else
-                {
-                    errors.error $(child) is not a subdir of $(parent) ;
-                }                        
-            }
-            else
-            {
-                return [ join $(split2) ] ;    
-            }        
-        }
-        else
-        {
-            return "." ;
-        }
-    }
-}
-
-
-# Returns the minimal path to path2 that is relative path1.
-#
-rule relative-to ( path1 path2 )
-{
-    local root_1 = [ regex.split [ reverse $(path1) ] / ] ;
-    local split1 = [ regex.split $(path1) / ] ;
-    local split2 = [ regex.split $(path2) / ] ;
-
-    while $(split1) && $(root_1)
-    {
-        if $(split1[1]) = $(split2[1])
-        {
-            root_1 = $(root_1[2-]) ;
-            split1 = $(split1[2-]) ;
-            split2 = $(split2[2-]) ;
-        }
-        else
-        {
-            split1 = ;
-        }
-    }
-    return [ join . $(root_1) $(split2) ] ;
-}
-
-
-# Returns the list of paths which are used by the operating system for looking
-# up programs.
-#
-rule programs-path ( )
-{
-    local result ;
-    local raw = [ modules.peek : PATH Path path ] ;
-    for local p in $(raw)
-    {
-        if $(p)
-        {
-            result += [ path.make $(p) ] ;
-        }
-    }
-    return $(result) ;
-}
-
-rule makedirs ( path )
-{
-    local result = true ;
-    local native = [ native $(path) ] ;
-    if ! [ exists $(native) ]
-    {
-        if [ makedirs [ parent $(path) ] ]
-        {            
-            if ! [ MAKEDIR $(native) ]
-            {
-                errors.error "Could not create directory '$(path)'" ;
-                result = ;
-            }
-        }        
-    }    
-    return $(result) ;
-}
-
-# Converts native Windows paths into our internal canonic path representation.
-# Supports 'invalid' paths containing multiple successive path separator
-# characters.
-#
-# TODO: Check and if needed add support for Windows 'X:file' path format where
-# the file is located in the current folder on drive X.
-#
-rule make-NT ( native )
-{
-    local result ;
-
-    if [ version.check-jam-version 3 1 17 ]
-    {
-        result = [ NORMALIZE_PATH $(native) ] ;
-    }
-    else
-    {
-        # This old implementation is really fragile due to a not so clear way
-        # NORMALIZE_PATH rule worked in Boost.Jam versions prior to 3.1.17. E.g.
-        # path.join would mostly ignore empty path elements but would root the
-        # joined path in case the initial two path elements were empty or some
-        # similar accidental wierdness.
-        result = [ path.join [ regex.split $(native) "[/\\]" ] ] ;
-    }
-
-    # We need to add an extra '/' in front in case this is a rooted Windows path
-    # starting with a drive letter and not a path separator character since the
-    # builtin NORMALIZE_PATH rule has no knowledge of this leading drive letter
-    # and treats it as a regular folder name.
-    if [ regex.match "(^.:)" : $(native) ]
-    {
-        result = /$(result) ;
-    }
-
-    return $(result) ;
-}
-
-
-rule native-NT ( path )
-{
-    local result ;
-    if [ is-rooted $(path) ] && ! [ regex.match "^/(.:)" : $(path) ]
-    {
-        result = $(path) ;
-    }
-    else
-    {
-        result = [ MATCH "^/?(.*)" : $(path) ] ;
-    }
-    result = [ sequence.join [ regex.split $(result) "/" ] : "\\" ] ;
-    return $(result) ;
-}
-
-
-rule make-UNIX ( native )
-{
-    # VP: I have no idea now 'native' can be empty here! But it can!
-    if ! $(native)
-    {
-        errors.error "Empty path passed to 'make-UNIX'" ;
-    }
-    else
-    {
-        return [ NORMALIZE_PATH $(native:T) ] ;
-    }
-}
-
-
-rule native-UNIX ( path )
-{
-    return $(path) ;
-}
-
-
-rule make-CYGWIN ( path )
-{
-    return [ make-NT $(path) ] ;
-}
-
-
-rule native-CYGWIN ( path )
-{
-    local result = $(path) ;
-    if [ regex.match "(^/.:)" : $(path)  ]  # Windows absolute path.
-    {
-        result = [ MATCH "^/?(.*)" : $(path) ] ;  # Remove leading '/'.
-    }
-    return [ native-UNIX $(result) ] ;
-}
-
-
-# split-path-VMS: splits input native path into device dir file (each part is
-# optional).
-#
-# example:
-#
-# dev:[dir]file.c => dev: [dir] file.c
-#
-rule split-path-VMS ( native )
-{
-    local matches = [ MATCH ([a-zA-Z0-9_-]+:)?(\\[[^\]]*\\])?(.*)?$   : $(native) ] ;
-    local device = $(matches[1]) ;
-    local dir = $(matches[2]) ;
-    local file = $(matches[3]) ;
-
-    return $(device) $(dir) $(file) ;
-}
-
-
-# Converts a native VMS path into a portable path spec.
-#
-# Does not handle current-device absolute paths such as "[dir]File.c" as it is
-# not clear how to represent them in the portable path notation.
-#
-# Adds a trailing dot (".") to the file part if no extension is present (helps
-# when converting it back into native path).
-#
-rule make-VMS ( native )
-{
-    if [ MATCH ^(\\[[a-zA-Z0-9]) : $(native) ]
-    {
-        errors.error "Can't handle default-device absolute paths: " $(native) ;
-    }
-
-    local parts = [ split-path-VMS $(native) ] ;
-    local device = $(parts[1]) ;
-    local dir = $(parts[2]) ;
-    local file = $(parts[3]) ;
-    local elems ;
-
-    if $(device)
-    {
-        #
-        # rooted
-        #
-        elems = /$(device) ;
-    }
-
-    if $(dir) = "[]"
-    {
-        #
-        # Special case: current directory
-        #
-        elems = $(elems) "." ;
-    }
-    else if $(dir)
-    {
-        dir = [ regex.replace $(dir) "\\[|\\]" "" ] ;
-        local dir_parts = [ regex.split $(dir) \\. ]  ;
-
-        if $(dir_parts[1]) = ""
-        {
-            #
-            # Relative path
-            #
-            dir_parts = $(dir_parts[2--1]) ;
-        }
-
-        #
-        # replace "parent-directory" parts (- => ..)
-        #
-        dir_parts = [ regex.replace-list $(dir_parts) : - : .. ] ;
-
-        elems = $(elems) $(dir_parts) ;
-    }
-
-    if $(file)
-    {
-        if ! [ MATCH (\\.) : $(file) ]
-        {
-            #
-            # Always add "." to end of non-extension file.
-            #
-            file = $(file). ;
-        }
-        elems = $(elems) $(file) ;
-    }
-
-    local portable = [ path.join $(elems) ] ;
-
-    return $(portable) ;
-}
-
-
-# Converts a portable path spec into a native VMS path.
-#
-# Relies on having at least one dot (".") included in the file name to be able
-# to differentiate it from the directory part.
-#
-rule native-VMS ( path )
-{
-    local device = "" ;
-    local dir = $(path) ;
-    local file = "" ;
-    local native ;
-    local split ;
-
-    #
-    # Has device ?
-    #
-    if [ is-rooted $(dir) ]
-    {
-        split = [ MATCH ^/([^:]+:)/?(.*) : $(dir) ] ;
-        device = $(split[1]) ;
-        dir = $(split[2]) ;
-    }
-
-    #
-    # Has file ?
-    #
-    # This is no exact science, just guess work:
-    #
-    # If the last part of the current path spec
-    # includes some chars, followed by a dot,
-    # optionally followed by more chars -
-    # then it is a file (keep your fingers crossed).
-    #
-    split = [ regex.split $(dir) / ] ;
-    local maybe_file = $(split[-1]) ;
-
-    if [ MATCH ^([^.]+\\..*) : $(maybe_file) ]
-    {
-        file = $(maybe_file) ;
-        dir = [ sequence.join $(split[1--2]) : / ] ;
-    }
-
-    #
-    # Has dir spec ?
-    #
-    if $(dir) = "."
-    {
-        dir = "[]" ;
-    }
-    else if $(dir)
-    {
-        dir = [ regex.replace $(dir) \\.\\. - ] ;
-        dir = [ regex.replace $(dir) / . ] ;
-
-        if $(device) = ""
-        {
-            #
-            # Relative directory
-            #
-            dir = "."$(dir) ;
-        }
-        dir = "["$(dir)"]" ;
-    }
-
-    native = [ sequence.join $(device) $(dir) $(file) ] ;
-
-    return $(native) ;
-}
-
-
-rule __test__ ( )
-{
-    import assert ;
-    import errors : try catch ;
-
-    assert.true is-rooted "/" ;
-    assert.true is-rooted "/foo" ;
-    assert.true is-rooted "/foo/bar" ;
-    assert.result : is-rooted "." ;
-    assert.result : is-rooted "foo" ;
-    assert.result : is-rooted "foo/bar" ;
-
-    assert.true has-parent "foo" ;
-    assert.true has-parent "foo/bar" ;
-    assert.true has-parent "." ;
-    assert.result : has-parent "/" ;
-
-    assert.result "." : basename "." ;
-    assert.result ".." : basename ".." ;
-    assert.result "foo" : basename "foo" ;
-    assert.result "foo" : basename "bar/foo" ;
-    assert.result "foo" : basename "gaz/bar/foo" ;
-    assert.result "foo" : basename "/gaz/bar/foo" ;
-
-    assert.result "." : parent "foo" ;
-    assert.result "/" : parent "/foo" ;
-    assert.result "foo/bar" : parent "foo/bar/giz" ;
-    assert.result ".." : parent "." ;
-    assert.result ".." : parent "../foo" ;
-    assert.result "../../foo" : parent "../../foo/bar" ;
-
-    assert.result "." : reverse "." ;
-    assert.result ".." : reverse "foo" ;
-    assert.result "../../.." : reverse "foo/bar/giz" ;
-
-    assert.result "foo" : join "foo" ;
-    assert.result "/foo" : join "/" "foo" ;
-    assert.result "foo/bar" : join "foo" "bar" ;
-    assert.result "foo/bar" : join "foo/giz" "../bar" ;
-    assert.result "foo/giz" : join "foo/bar/baz" "../../giz" ;
-    assert.result ".." : join "." ".." ;
-    assert.result ".." : join "foo" "../.." ;
-    assert.result "../.." : join "../foo" "../.." ;
-    assert.result "/foo" : join "/bar" "../foo" ;
-    assert.result "foo/giz" : join "foo/giz" "." ;
-    assert.result "." : join lib2 ".." ;
-    assert.result "/" : join "/a" ".." ;
-
-    assert.result /a/b : join /a/b/c .. ;
-
-    assert.result "foo/bar/giz" : join "foo" "bar" "giz" ;
-    assert.result "giz" : join "foo" ".." "giz" ;
-    assert.result "foo/giz" : join "foo" "." "giz" ;
-
-    try ;
-    {
-        join "a" "/b" ;
-    }
-    catch only first element may be rooted ;
-
-    local CWD = "/home/ghost/build" ;
-    assert.result : all-parents . : . : $(CWD) ;
-    assert.result . .. ../.. ../../..  : all-parents "Jamfile" : "" : $(CWD) ;
-    assert.result foo . .. ../.. ../../.. : all-parents "foo/Jamfile" : "" : $(CWD) ;
-    assert.result ../Work .. ../.. ../../.. : all-parents "../Work/Jamfile" : "" : $(CWD) ;
-
-    local CWD = "/home/ghost" ;
-    assert.result . .. : all-parents "Jamfile" : "/home" : $(CWD) ;
-    assert.result . : all-parents "Jamfile" : "/home/ghost" : $(CWD) ;
-
-    assert.result "c/d" : relative "a/b/c/d" "a/b" ;
-    assert.result "foo" : relative "foo" "." ;
-
-    local save-os = [ modules.peek path : os ] ;
-    modules.poke path : os : NT ;
-
-    assert.result "foo/bar/giz" : make "foo/bar/giz" ;
-    assert.result "foo/bar/giz" : make "foo\\bar\\giz" ;
-    assert.result "foo" : make "foo/" ;
-    assert.result "foo" : make "foo\\" ;
-    assert.result "foo" : make "foo/." ;
-    assert.result "foo" : make "foo/bar/.." ;
-    assert.result "foo" : make "foo/bar/../" ;
-    assert.result "foo" : make "foo/bar/..\\" ;
-    assert.result "foo/bar" : make "foo/././././bar" ;
-    assert.result "/foo" : make "\\foo" ;
-    assert.result "/D:/My Documents" : make "D:\\My Documents" ;
-    assert.result "/c:/boost/tools/build/new/project.jam" : make "c:\\boost\\tools\\build\\test\\..\\new\\project.jam" ;
-    
-    #   Test processing 'invalid' paths containing multiple successive path
-    # separators.
-    assert.result "foo" : make "foo//" ;
-    assert.result "foo" : make "foo///" ;
-    assert.result "foo" : make "foo\\\\" ;
-    assert.result "foo" : make "foo\\\\\\" ;
-    assert.result "/foo" : make "//foo" ;
-    assert.result "/foo" : make "///foo" ;
-    assert.result "/foo" : make "\\\\foo" ;
-    assert.result "/foo" : make "\\\\\\foo" ;
-    assert.result "/foo" : make "\\/\\/foo" ;
-    assert.result "foo/bar" : make "foo//\\//\\\\bar//\\//\\\\\\//\\//\\\\" ;
-    assert.result "foo" : make "foo/bar//.." ;
-    assert.result "foo/bar" : make "foo/bar/giz//.." ;
-    assert.result "foo/giz" : make "foo//\\//\\\\bar///\\\\//\\\\////\\/..///giz\\//\\\\\\//\\//\\\\" ;
-    assert.result "../../../foo" : make "..///.//..///.//..////foo///" ;
-
-    #   Test processing 'invalid' rooted paths with too many '..' path elements
-    # that would place them before the root.
-    assert.result : make "/.." ;
-    assert.result : make "/../" ;
-    assert.result : make "/../." ;
-    assert.result : make "/.././" ;
-    assert.result : make "/foo/../bar/giz/.././././../../." ;
-    assert.result : make "/foo/../bar/giz/.././././../.././" ;
-    assert.result : make "//foo/../bar/giz/.././././../../." ;
-    assert.result : make "//foo/../bar/giz/.././././../.././" ;
-    assert.result : make "\\\\foo/../bar/giz/.././././../../." ;
-    assert.result : make "\\\\foo/../bar/giz/.././././../.././" ;
-    assert.result : make "/..///.//..///.//..////foo///" ;
-
-    assert.result "foo\\bar\\giz" : native "foo/bar/giz" ;
-    assert.result "foo" : native "foo" ;
-    assert.result "\\foo" : native "/foo" ;
-    assert.result "D:\\My Documents\\Work" : native "/D:/My Documents/Work" ;
-
-    modules.poke path : os : UNIX ;
-
-    assert.result "foo/bar/giz" : make "foo/bar/giz" ;
-    assert.result "/sub1" : make "/sub1/." ;
-    assert.result "/sub1" : make "/sub1/sub2/.." ;
-    assert.result "sub1" : make "sub1/." ;
-    assert.result "sub1" : make "sub1/sub2/.." ;
-    assert.result "/foo/bar" : native "/foo/bar" ;
-
-    modules.poke path : os : VMS ;
-
-    #
-    # Don't really need to poke os before these
-    #
-    assert.result "disk:" "[dir]"  "file" : split-path-VMS "disk:[dir]file" ;
-    assert.result "disk:" "[dir]"  ""     : split-path-VMS "disk:[dir]" ;
-    assert.result "disk:" ""       ""     : split-path-VMS "disk:" ;
-    assert.result "disk:" ""       "file" : split-path-VMS "disk:file" ;
-    assert.result ""      "[dir]"  "file" : split-path-VMS "[dir]file" ;
-    assert.result ""      "[dir]"  ""     : split-path-VMS "[dir]" ;
-    assert.result ""      ""       "file" : split-path-VMS "file" ;
-    assert.result ""      ""       ""     : split-path-VMS "" ;
-
-    #
-    # Special case: current directory
-    #
-    assert.result ""      "[]"     ""     : split-path-VMS "[]" ;
-    assert.result "disk:" "[]"     ""     : split-path-VMS "disk:[]" ;
-    assert.result ""      "[]"     "file" : split-path-VMS "[]file" ;
-    assert.result "disk:" "[]"     "file" : split-path-VMS "disk:[]file" ;
-
-    #
-    # Make portable paths
-    #
-    assert.result "/disk:" : make "disk:" ;
-    assert.result "foo/bar/giz" : make "[.foo.bar.giz]" ;
-    assert.result "foo" : make "[.foo]" ;
-    assert.result "foo" : make "[.foo.bar.-]" ;
-    assert.result ".." : make "[.-]" ;
-    assert.result ".." : make "[-]" ;
-    assert.result "." : make "[]" ;
-    assert.result "giz.h" : make "giz.h" ;
-    assert.result "foo/bar/giz.h" : make "[.foo.bar]giz.h" ;
-    assert.result "/disk:/my_docs" : make "disk:[my_docs]" ;
-    assert.result "/disk:/boost/tools/build/new/project.jam" : make "disk:[boost.tools.build.test.-.new]project.jam" ;
-
-    #
-    # Special case (adds '.' to end of file w/o extension to
-    # disambiguate from directory in portable path spec).
-    #
-    assert.result "Jamfile." : make "Jamfile" ;
-    assert.result "dir/Jamfile." : make "[.dir]Jamfile" ;
-    assert.result "/disk:/dir/Jamfile." : make "disk:[dir]Jamfile" ;
-
-    #
-    # Make native paths
-    #
-    assert.result "disk:" : native "/disk:" ;
-    assert.result "[.foo.bar.giz]" : native "foo/bar/giz" ;
-    assert.result "[.foo]" : native "foo" ;
-    assert.result "[.-]" : native ".." ;
-    assert.result "[.foo.-]" : native "foo/.." ;
-    assert.result "[]" : native "." ;
-    assert.result "disk:[my_docs.work]" : native "/disk:/my_docs/work" ;
-    assert.result "giz.h" : native "giz.h" ;
-    assert.result "disk:Jamfile." : native "/disk:Jamfile." ;
-    assert.result "disk:[my_docs.work]Jamfile." : native "/disk:/my_docs/work/Jamfile." ;
-
-    modules.poke path : os : $(save-os) ;
-}