351 lines
8.7 KiB
Go
351 lines
8.7 KiB
Go
// 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.
|
|
|
|
// The filepath package implements utility routines for manipulating
|
|
// filename paths in a way compatible with the target operating
|
|
// system-defined file paths.
|
|
package filepath
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
SeparatorString = string(Separator)
|
|
ListSeparatorString = string(ListSeparator)
|
|
)
|
|
|
|
// 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 Separator elements with a single one.
|
|
// 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,
|
|
// assuming Separator is '/'.
|
|
//
|
|
// 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 := IsAbs(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.
|
|
prefix := volumeName(path)
|
|
path = path[len(prefix):]
|
|
n := len(path)
|
|
buf := []byte(path)
|
|
r, w, dotdot := 0, 0, 0
|
|
if rooted {
|
|
buf[0] = Separator
|
|
r, w, dotdot = 1, 1, 1
|
|
}
|
|
|
|
for r < n {
|
|
switch {
|
|
case isSeparator(path[r]):
|
|
// empty path element
|
|
r++
|
|
case path[r] == '.' && (r+1 == n || isSeparator(path[r+1])):
|
|
// . element
|
|
r++
|
|
case path[r] == '.' && path[r+1] == '.' && (r+2 == n || isSeparator(path[r+2])):
|
|
// .. element: remove to last separator
|
|
r += 2
|
|
switch {
|
|
case w > dotdot:
|
|
// can backtrack
|
|
w--
|
|
for w > dotdot && !isSeparator(buf[w]) {
|
|
w--
|
|
}
|
|
case !rooted:
|
|
// cannot backtrack, but not rooted, so append .. element.
|
|
if w > 0 {
|
|
buf[w] = Separator
|
|
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] = Separator
|
|
w++
|
|
}
|
|
// copy element
|
|
for ; r < n && !isSeparator(path[r]); r++ {
|
|
buf[w] = path[r]
|
|
w++
|
|
}
|
|
}
|
|
}
|
|
|
|
// Turn empty string into "."
|
|
if w == 0 {
|
|
buf[w] = '.'
|
|
w++
|
|
}
|
|
|
|
return prefix + string(buf[0:w])
|
|
}
|
|
|
|
// ToSlash returns the result of replacing each separator character
|
|
// in path with a slash ('/') character.
|
|
func ToSlash(path string) string {
|
|
if Separator == '/' {
|
|
return path
|
|
}
|
|
return strings.Replace(path, SeparatorString, "/", -1)
|
|
}
|
|
|
|
// FromSlash returns the result of replacing each slash ('/') character
|
|
// in path with a separator character.
|
|
func FromSlash(path string) string {
|
|
if Separator == '/' {
|
|
return path
|
|
}
|
|
return strings.Replace(path, "/", SeparatorString, -1)
|
|
}
|
|
|
|
// SplitList splits a list of paths joined by the OS-specific ListSeparator.
|
|
func SplitList(path string) []string {
|
|
if path == "" {
|
|
return []string{}
|
|
}
|
|
return strings.Split(path, ListSeparatorString, -1)
|
|
}
|
|
|
|
// Split splits path immediately following the final Separator,
|
|
// partitioning it into a directory and a file name components.
|
|
// If there are no separators in path, Split returns an empty base
|
|
// and file set to path.
|
|
func Split(path string) (dir, file string) {
|
|
i := len(path) - 1
|
|
for i >= 0 && !isSeparator(path[i]) {
|
|
i--
|
|
}
|
|
return path[:i+1], path[i+1:]
|
|
}
|
|
|
|
// Join joins any number of path elements into a single path, adding
|
|
// a Separator 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:], SeparatorString))
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// Ext returns the file name extension used by path.
|
|
// The extension is the suffix beginning at the final dot
|
|
// in the final element of path; it is empty if there is
|
|
// no dot.
|
|
func Ext(path string) string {
|
|
for i := len(path) - 1; i >= 0 && !isSeparator(path[i]); i-- {
|
|
if path[i] == '.' {
|
|
return path[i:]
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// EvalSymlinks returns the path name after the evaluation of any symbolic
|
|
// links.
|
|
// If path is relative it will be evaluated relative to the current directory.
|
|
func EvalSymlinks(path string) (string, os.Error) {
|
|
const maxIter = 255
|
|
originalPath := path
|
|
// consume path by taking each frontmost path element,
|
|
// expanding it if it's a symlink, and appending it to b
|
|
var b bytes.Buffer
|
|
for n := 0; path != ""; n++ {
|
|
if n > maxIter {
|
|
return "", os.NewError("EvalSymlinks: too many links in " + originalPath)
|
|
}
|
|
|
|
// find next path component, p
|
|
i := strings.IndexRune(path, Separator)
|
|
var p string
|
|
if i == -1 {
|
|
p, path = path, ""
|
|
} else {
|
|
p, path = path[:i], path[i+1:]
|
|
}
|
|
|
|
if p == "" {
|
|
if b.Len() == 0 {
|
|
// must be absolute path
|
|
b.WriteRune(Separator)
|
|
}
|
|
continue
|
|
}
|
|
|
|
fi, err := os.Lstat(b.String() + p)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if !fi.IsSymlink() {
|
|
b.WriteString(p)
|
|
if path != "" {
|
|
b.WriteRune(Separator)
|
|
}
|
|
continue
|
|
}
|
|
|
|
// it's a symlink, put it at the front of path
|
|
dest, err := os.Readlink(b.String() + p)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if IsAbs(dest) {
|
|
b.Reset()
|
|
}
|
|
path = dest + SeparatorString + path
|
|
}
|
|
return Clean(b.String()), nil
|
|
}
|
|
|
|
// Abs returns an absolute representation of path.
|
|
// If the path is not absolute it will be joined with the current
|
|
// working directory to turn it into an absolute path. The absolute
|
|
// path name for a given file is not guaranteed to be unique.
|
|
func Abs(path string) (string, os.Error) {
|
|
if IsAbs(path) {
|
|
return path, nil
|
|
}
|
|
wd, err := os.Getwd()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return Join(wd, path), nil
|
|
}
|
|
|
|
// Visitor methods are invoked for corresponding file tree entries
|
|
// visited by Walk. The parameter path is the full path of f relative
|
|
// to root.
|
|
type Visitor interface {
|
|
VisitDir(path string, f *os.FileInfo) bool
|
|
VisitFile(path string, f *os.FileInfo)
|
|
}
|
|
|
|
func walk(path string, f *os.FileInfo, v Visitor, errors chan<- os.Error) {
|
|
if !f.IsDirectory() {
|
|
v.VisitFile(path, f)
|
|
return
|
|
}
|
|
|
|
if !v.VisitDir(path, f) {
|
|
return // skip directory entries
|
|
}
|
|
|
|
list, err := readDir(path)
|
|
if err != nil {
|
|
if errors != nil {
|
|
errors <- err
|
|
}
|
|
}
|
|
|
|
for _, e := range list {
|
|
walk(Join(path, e.Name), e, v, errors)
|
|
}
|
|
}
|
|
|
|
// readDir reads the directory named by dirname and returns
|
|
// a list of sorted directory entries.
|
|
// Copied from io/ioutil to avoid the circular import.
|
|
func readDir(dirname string) ([]*os.FileInfo, os.Error) {
|
|
f, err := os.Open(dirname)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
list, err := f.Readdir(-1)
|
|
f.Close()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fi := make(fileInfoList, len(list))
|
|
for i := range list {
|
|
fi[i] = &list[i]
|
|
}
|
|
sort.Sort(fi)
|
|
return fi, nil
|
|
}
|
|
|
|
// A dirList implements sort.Interface.
|
|
type fileInfoList []*os.FileInfo
|
|
|
|
func (f fileInfoList) Len() int { return len(f) }
|
|
func (f fileInfoList) Less(i, j int) bool { return f[i].Name < f[j].Name }
|
|
func (f fileInfoList) Swap(i, j int) { f[i], f[j] = f[j], f[i] }
|
|
|
|
// Walk walks the file tree rooted at root, calling v.VisitDir or
|
|
// v.VisitFile for each directory or file in the tree, including root.
|
|
// If v.VisitDir returns false, Walk skips the directory's entries;
|
|
// otherwise it invokes itself for each directory entry in sorted order.
|
|
// An error reading a directory does not abort the Walk.
|
|
// If errors != nil, Walk sends each directory read error
|
|
// to the channel. Otherwise Walk discards the error.
|
|
func Walk(root string, v Visitor, errors chan<- os.Error) {
|
|
f, err := os.Lstat(root)
|
|
if err != nil {
|
|
if errors != nil {
|
|
errors <- err
|
|
}
|
|
return // can't progress
|
|
}
|
|
walk(root, f, v, errors)
|
|
}
|
|
|
|
// Base returns the last element of path.
|
|
// Trailing path separators are removed before extracting the last element.
|
|
// If the path is empty, Base returns ".".
|
|
// If the path consists entirely of separators, Base returns a single separator.
|
|
func Base(path string) string {
|
|
if path == "" {
|
|
return "."
|
|
}
|
|
// Strip trailing slashes.
|
|
for len(path) > 0 && isSeparator(path[len(path)-1]) {
|
|
path = path[0 : len(path)-1]
|
|
}
|
|
// Find the last element
|
|
i := len(path) - 1
|
|
for i >= 0 && !isSeparator(path[i]) {
|
|
i--
|
|
}
|
|
if i >= 0 {
|
|
path = path[i+1:]
|
|
}
|
|
// If empty now, it had only slashes.
|
|
if path == "" {
|
|
return SeparatorString
|
|
}
|
|
return path
|
|
}
|