1 // Copyright 2009 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 // Package path implements utility routines for manipulating slash-separated 6 // paths. 7 // 8 // The path package should only be used for paths separated by forward 9 // slashes, such as the paths in URLs. This package does not deal with 10 // Windows paths with drive letters or backslashes; to manipulate 11 // operating system paths, use the path/filepath package. 12 package path 13 14 // A lazybuf is a lazily constructed path buffer. 15 // It supports append, reading previously appended bytes, 16 // and retrieving the final string. It does not allocate a buffer 17 // to hold the output until that output diverges from s. 18 type lazybuf struct { 19 s string 20 buf []byte 21 w int 22 } 23 24 func (b *lazybuf) index(i int) byte { 25 if b.buf != nil { 26 return b.buf[i] 27 } 28 return b.s[i] 29 } 30 31 func (b *lazybuf) append(c byte) { 32 if b.buf == nil { 33 if b.w < len(b.s) && b.s[b.w] == c { 34 b.w++ 35 return 36 } 37 b.buf = make([]byte, len(b.s)) 38 copy(b.buf, b.s[:b.w]) 39 } 40 b.buf[b.w] = c 41 b.w++ 42 } 43 44 func (b *lazybuf) string() string { 45 if b.buf == nil { 46 return b.s[:b.w] 47 } 48 return string(b.buf[:b.w]) 49 } 50 51 // Clean returns the shortest path name equivalent to path 52 // by purely lexical processing. It applies the following rules 53 // iteratively until no further processing can be done: 54 // 55 // 1. Replace multiple slashes with a single slash. 56 // 2. Eliminate each . path name element (the current directory). 57 // 3. Eliminate each inner .. path name element (the parent directory) 58 // along with the non-.. element that precedes it. 59 // 4. Eliminate .. elements that begin a rooted path: 60 // that is, replace "/.." by "/" at the beginning of a path. 61 // 62 // The returned path ends in a slash only if it is the root "/". 63 // 64 // If the result of this process is an empty string, Clean 65 // returns the string ".". 66 // 67 // See also Rob Pike, ``Lexical File Names in Plan 9 or 68 // Getting Dot-Dot Right,'' 69 // https://9p.io/sys/doc/lexnames.html 70 func Clean(path string) string { 71 if path == "" { 72 return "." 73 } 74 75 rooted := path[0] == '/' 76 n := len(path) 77 78 // Invariants: 79 // reading from path; r is index of next byte to process. 80 // writing to buf; w is index of next byte to write. 81 // dotdot is index in buf where .. must stop, either because 82 // it is the leading slash or it is a leading ../../.. prefix. 83 out := lazybuf{s: path} 84 r, dotdot := 0, 0 85 if rooted { 86 out.append('/') 87 r, dotdot = 1, 1 88 } 89 90 for r < n { 91 switch { 92 case path[r] == '/': 93 // empty path element 94 r++ 95 case path[r] == '.' && (r+1 == n || path[r+1] == '/'): 96 // . element 97 r++ 98 case path[r] == '.' && path[r+1] == '.' && (r+2 == n || path[r+2] == '/'): 99 // .. element: remove to last / 100 r += 2 101 switch { 102 case out.w > dotdot: 103 // can backtrack 104 out.w-- 105 for out.w > dotdot && out.index(out.w) != '/' { 106 out.w-- 107 } 108 case !rooted: 109 // cannot backtrack, but not rooted, so append .. element. 110 if out.w > 0 { 111 out.append('/') 112 } 113 out.append('.') 114 out.append('.') 115 dotdot = out.w 116 } 117 default: 118 // real path element. 119 // add slash if needed 120 if rooted && out.w != 1 || !rooted && out.w != 0 { 121 out.append('/') 122 } 123 // copy element 124 for ; r < n && path[r] != '/'; r++ { 125 out.append(path[r]) 126 } 127 } 128 } 129 130 // Turn empty string into "." 131 if out.w == 0 { 132 return "." 133 } 134 135 return out.string() 136 } 137 138 // lastSlash(s) is strings.LastIndex(s, "/") but we can't import strings. 139 func lastSlash(s string) int { 140 i := len(s) - 1 141 for i >= 0 && s[i] != '/' { 142 i-- 143 } 144 return i 145 } 146 147 // Split splits path immediately following the final slash, 148 // separating it into a directory and file name component. 149 // If there is no slash in path, Split returns an empty dir and 150 // file set to path. 151 // The returned values have the property that path = dir+file. 152 func Split(path string) (dir, file string) { 153 i := lastSlash(path) 154 return path[:i+1], path[i+1:] 155 } 156 157 // Join joins any number of path elements into a single path, 158 // separating them with slashes. Empty elements are ignored. 159 // The result is Cleaned. However, if the argument list is 160 // empty or all its elements are empty, Join returns 161 // an empty string. 162 func Join(elem ...string) string { 163 size := 0 164 for _, e := range elem { 165 size += len(e) 166 } 167 if size == 0 { 168 return "" 169 } 170 buf := make([]byte, 0, size+len(elem)-1) 171 for _, e := range elem { 172 if len(buf) > 0 || e != "" { 173 if len(buf) > 0 { 174 buf = append(buf, '/') 175 } 176 buf = append(buf, e...) 177 } 178 } 179 return Clean(string(buf)) 180 } 181 182 // Ext returns the file name extension used by path. 183 // The extension is the suffix beginning at the final dot 184 // in the final slash-separated element of path; 185 // it is empty if there is no dot. 186 func Ext(path string) string { 187 for i := len(path) - 1; i >= 0 && path[i] != '/'; i-- { 188 if path[i] == '.' { 189 return path[i:] 190 } 191 } 192 return "" 193 } 194 195 // Base returns the last element of path. 196 // Trailing slashes are removed before extracting the last element. 197 // If the path is empty, Base returns ".". 198 // If the path consists entirely of slashes, Base returns "/". 199 func Base(path string) string { 200 if path == "" { 201 return "." 202 } 203 // Strip trailing slashes. 204 for len(path) > 0 && path[len(path)-1] == '/' { 205 path = path[0 : len(path)-1] 206 } 207 // Find the last element 208 if i := lastSlash(path); i >= 0 { 209 path = path[i+1:] 210 } 211 // If empty now, it had only slashes. 212 if path == "" { 213 return "/" 214 } 215 return path 216 } 217 218 // IsAbs reports whether the path is absolute. 219 func IsAbs(path string) bool { 220 return len(path) > 0 && path[0] == '/' 221 } 222 223 // Dir returns all but the last element of path, typically the path's directory. 224 // After dropping the final element using Split, the path is Cleaned and trailing 225 // slashes are removed. 226 // If the path is empty, Dir returns ".". 227 // If the path consists entirely of slashes followed by non-slash bytes, Dir 228 // returns a single slash. In any other case, the returned path does not end in a 229 // slash. 230 func Dir(path string) string { 231 dir, _ := Split(path) 232 return Clean(dir) 233 } 234