c2047754c3
Compiler changes:
* Change map assignment to use mapassign and assign value directly.
* Change string iteration to use decoderune, faster for ASCII strings.
* Change makeslice to take int, and use makeslice64 for larger values.
* Add new noverflow field to hmap struct used for maps.
Unresolved problems, to be fixed later:
* Commented out test in go/types/sizes_test.go that doesn't compile.
* Commented out reflect.TestStructOf test for padding after zero-sized field.
Reviewed-on: https://go-review.googlesource.com/35231
gotools/:
Updates for Go 1.8rc1.
* Makefile.am (go_cmd_go_files): Add bug.go.
(s-zdefaultcc): Write defaultPkgConfig.
* Makefile.in: Rebuild.
From-SVN: r244456
115 lines
2.8 KiB
Go
115 lines
2.8 KiB
Go
// Copyright 2012 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
|
|
|
|
import (
|
|
"strings"
|
|
"syscall"
|
|
)
|
|
|
|
// normVolumeName is like VolumeName, but makes drive letter upper case.
|
|
// result of EvalSymlinks must be unique, so we have
|
|
// EvalSymlinks(`c:\a`) == EvalSymlinks(`C:\a`).
|
|
func normVolumeName(path string) string {
|
|
volume := VolumeName(path)
|
|
|
|
if len(volume) > 2 { // isUNC
|
|
return volume
|
|
}
|
|
|
|
return strings.ToUpper(volume)
|
|
}
|
|
|
|
// normBase returns the last element of path with correct case.
|
|
func normBase(path string) (string, error) {
|
|
p, err := syscall.UTF16PtrFromString(path)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
var data syscall.Win32finddata
|
|
|
|
h, err := syscall.FindFirstFile(p, &data)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
syscall.FindClose(h)
|
|
|
|
return syscall.UTF16ToString(data.FileName[:]), nil
|
|
}
|
|
|
|
// baseIsDotDot returns whether the last element of path is "..".
|
|
// The given path should be 'Clean'-ed in advance.
|
|
func baseIsDotDot(path string) bool {
|
|
i := strings.LastIndexByte(path, Separator)
|
|
return path[i+1:] == ".."
|
|
}
|
|
|
|
// toNorm returns the normalized path that is guaranteed to be unique.
|
|
// It should accept the following formats:
|
|
// * UNC paths (e.g \\server\share\foo\bar)
|
|
// * absolute paths (e.g C:\foo\bar)
|
|
// * relative paths begin with drive letter (e.g C:foo\bar, C:..\foo\bar, C:.., C:.)
|
|
// * relative paths begin with '\' (e.g \foo\bar)
|
|
// * relative paths begin without '\' (e.g foo\bar, ..\foo\bar, .., .)
|
|
// The returned normalized path will be in the same form (of 5 listed above) as the input path.
|
|
// If two paths A and B are indicating the same file with the same format, toNorm(A) should be equal to toNorm(B).
|
|
// The normBase parameter should be equal to the normBase func, except for in tests. See docs on the normBase func.
|
|
func toNorm(path string, normBase func(string) (string, error)) (string, error) {
|
|
if path == "" {
|
|
return path, nil
|
|
}
|
|
|
|
path = Clean(path)
|
|
|
|
volume := normVolumeName(path)
|
|
path = path[len(volume):]
|
|
|
|
// skip special cases
|
|
if path == "." || path == `\` {
|
|
return volume + path, nil
|
|
}
|
|
|
|
var normPath string
|
|
|
|
for {
|
|
if baseIsDotDot(path) {
|
|
normPath = path + `\` + normPath
|
|
|
|
break
|
|
}
|
|
|
|
name, err := normBase(volume + path)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
normPath = name + `\` + normPath
|
|
|
|
i := strings.LastIndexByte(path, Separator)
|
|
if i == -1 {
|
|
break
|
|
}
|
|
if i == 0 { // `\Go` or `C:\Go`
|
|
normPath = `\` + normPath
|
|
|
|
break
|
|
}
|
|
|
|
path = path[:i]
|
|
}
|
|
|
|
normPath = normPath[:len(normPath)-1] // remove trailing '\'
|
|
|
|
return volume + normPath, nil
|
|
}
|
|
|
|
func evalSymlinks(path string) (string, error) {
|
|
path, err := walkSymlinks(path)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return toNorm(path, normBase)
|
|
}
|