| // 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 filepath implements utility routines for manipulating filename paths | |
| // in a way compatible with the target operating system-defined file paths. | |
| package filepath | |
| import ( | |
| "bytes" | |
| "os" | |
| "runtime" | |
| "sort" | |
| "strings" | |
| ) | |
| const ( | |
| Separator = os.PathSeparator | |
| ListSeparator = os.PathListSeparator | |
| ) | |
| // 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 { | |
| vol := VolumeName(path) | |
| path = path[len(vol):] | |
| if path == "" { | |
| return vol + "." | |
| } | |
| rooted := os.IsPathSeparator(path[0]) | |
| // 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. | |
| 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 os.IsPathSeparator(path[r]): | |
| // empty path element | |
| r++ | |
| case path[r] == '.' && (r+1 == n || os.IsPathSeparator(path[r+1])): | |
| // . element | |
| r++ | |
| case path[r] == '.' && path[r+1] == '.' && (r+2 == n || os.IsPathSeparator(path[r+2])): | |
| // .. element: remove to last separator | |
| r += 2 | |
| switch { | |
| case w > dotdot: | |
| // can backtrack | |
| w-- | |
| for w > dotdot && !os.IsPathSeparator(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 && !os.IsPathSeparator(path[r]); r++ { | |
| buf[w] = path[r] | |
| w++ | |
| } | |
| } | |
| } | |
| // Turn empty string into "." | |
| if w == 0 { | |
| buf[w] = '.' | |
| w++ | |
| } | |
| return FromSlash(vol + 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, string(Separator), "/", -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, "/", string(Separator), -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, string(ListSeparator)) | |
| } | |
| // Split splits path immediately following the final 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 := len(path) - 1 | |
| for i >= 0 && !os.IsPathSeparator(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:], string(Separator))) | |
| } | |
| } | |
| 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 && !os.IsPathSeparator(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) { | |
| if runtime.GOOS == "windows" { | |
| // Symlinks are not supported under windows. | |
| _, err := os.Lstat(path) | |
| if err != nil { | |
| return "", err | |
| } | |
| return Clean(path), nil | |
| } | |
| 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 + string(Separator) + 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 Clean(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 && os.IsPathSeparator(path[len(path)-1]) { | |
| path = path[0 : len(path)-1] | |
| } | |
| // Find the last element | |
| i := len(path) - 1 | |
| for i >= 0 && !os.IsPathSeparator(path[i]) { | |
| i-- | |
| } | |
| if i >= 0 { | |
| path = path[i+1:] | |
| } | |
| // If empty now, it had only slashes. | |
| if path == "" { | |
| return string(Separator) | |
| } | |
| return path | |
| } |