Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package path implements utility routines for manipulating slash-separated
// filename paths.
package path

import (
        "strings"
)

// Clean returns the shortest path name equivalent to path
// by purely lexical processing.  It applies the following rules
// iteratively until no further processing can be done:
//
//      1. Replace multiple slashes with a single slash.
//      2. Eliminate each . path name element (the current directory).
//      3. Eliminate each inner .. path name element (the parent directory)
//         along with the non-.. element that precedes it.
//      4. Eliminate .. elements that begin a rooted path:
//         that is, replace "/.." by "/" at the beginning of a path.
//
// If the result of this process is an empty string, Clean
// returns the string ".".
//
// See also Rob Pike, ``Lexical File Names in Plan 9 or
// Getting Dot-Dot right,''
// http://plan9.bell-labs.com/sys/doc/lexnames.html
func Clean(path string) string {
        if path == "" {
                return "."
        }

        rooted := path[0] == '/'
        n := len(path)

        // Invariants:
        //      reading from path; r is index of next byte to process.
        //      writing to buf; w is index of next byte to write.
        //      dotdot is index in buf where .. must stop, either because
        //              it is the leading slash or it is a leading ../../.. prefix.
        buf := []byte(path)
        r, w, dotdot := 0, 0, 0
        if rooted {
                r, w, dotdot = 1, 1, 1
        }

        for r < n {
                switch {
                case path[r] == '/':
                        // empty path element
                        r++
                case path[r] == '.' && (r+1 == n || path[r+1] == '/'):
                        // . element
                        r++
                case path[r] == '.' && path[r+1] == '.' && (r+2 == n || path[r+2] == '/'):
                        // .. element: remove to last /
                        r += 2
                        switch {
                        case w > dotdot:
                                // can backtrack
                                w--
                                for w > dotdot && buf[w] != '/' {
                                        w--
                                }
                        case !rooted:
                                // cannot backtrack, but not rooted, so append .. element.
                                if w > 0 {
                                        buf[w] = '/'
                                        w++
                                }
                                buf[w] = '.'
                                w++
                                buf[w] = '.'
                                w++
                                dotdot = w
                        }
                default:
                        // real path element.
                        // add slash if needed
                        if rooted && w != 1 || !rooted && w != 0 {
                                buf[w] = '/'
                                w++
                        }
                        // copy element
                        for ; r < n && path[r] != '/'; r++ {
                                buf[w] = path[r]
                                w++
                        }
                }
        }

        // Turn empty string into "."
        if w == 0 {
                buf[w] = '.'
                w++
        }

        return string(buf[0:w])
}

// Split splits path immediately following the final path separator,
// separating it into a directory and file name component.
// If there is no separator in path, Split returns an empty dir and
// file set to path.
func Split(path string) (dir, file string) {
        i := strings.LastIndex(path, "/")
        return path[:i+1], path[i+1:]
}

// Join joins any number of path elements into a single path, adding a
// separating slash if necessary.  All empty strings are ignored.
func Join(elem ...string) string {
        for i, e := range elem {
                if e != "" {
                        return Clean(strings.Join(elem[i:], "/"))
                }
        }
        return ""
}

// Ext returns the file name extension used by path.
// The extension is the suffix beginning at the final dot
// in the final slash-separated element of path;
// it is empty if there is no dot.
func Ext(path string) string {
        for i := len(path) - 1; i >= 0 && path[i] != '/'; i-- {
                if path[i] == '.' {
                        return path[i:]
                }
        }
        return ""
}

// Base returns the last element of path.
// Trailing slashes are removed before extracting the last element.
// If the path is empty, Base returns ".".
// If the path consists entirely of slashes, Base returns "/".
func Base(path string) string {
        if path == "" {
                return "."
        }
        // Strip trailing slashes.
        for len(path) > 0 && path[len(path)-1] == '/' {
                path = path[0 : len(path)-1]
        }
        // Find the last element
        if i := strings.LastIndex(path, "/"); i >= 0 {
                path = path[i+1:]
        }
        // If empty now, it had only slashes.
        if path == "" {
                return "/"
        }
        return path
}

// IsAbs returns true if the path is absolute.
func IsAbs(path string) bool {
        return len(path) > 0 && path[0] == '/'
}

// Dir returns the all but the last element of path, typically the path's directory.
// Trailing path separators are removed before processing.
// If the path is empty, Dir returns ".".
// If the path consists entirely of separators, Dir returns a single separator.
// The returned path does not end in a separator unless it is the root directory.
func Dir(path string) string {
        dir, _ := Split(path)
        dir = Clean(dir)
        last := len(dir) - 1
        if last > 0 && dir[last] == '/' {
                dir = dir[:last]
        }
        if dir == "" {
                dir = "."
        }
        return dir
}