1 files changed, 0 insertions, 162 deletions
diff --git a/src/pkg/path/path.go b/src/pkg/path/path.go
deleted file mode 100644
index 235384667..000000000
--- a/src/pkg/path/path.go
+++ /dev/null
@@ -1,162 +0,0 @@
-// 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] == '/'
-}