Gecko [ 167.86.127.34 ]

Name	Size	Permission
example_test.go	475 B	-rw-r--r--
example_unix_test.go	3.32 KB	-rw-r--r--
example_unix_walk_test.go	1.52 KB	-rw-r--r--
export_test.go	198 B	-rw-r--r--
export_windows_test.go	226 B	-rw-r--r--
match.go	7.91 KB	-rw-r--r--
match_test.go	8.58 KB	-rw-r--r--
path.go	14.1 KB	-rw-r--r--
path_plan9.go	1.19 KB	-rw-r--r--
path_test.go	34.81 KB	-rw-r--r--
path_unix.go	1.24 KB	-rw-r--r--
path_windows.go	4.88 KB	-rw-r--r--
path_windows_test.go	16.06 KB	-rw-r--r--
symlink.go	3.16 KB	-rw-r--r--
symlink_unix.go	116 B	-rw-r--r--
symlink_windows.go	2.9 KB	-rw-r--r--

Code Editor : symlink_windows.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 reports 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) {
	newpath, err := walkSymlinks(path)
	if err != nil {
		return "", err
	}
	newpath, err = toNorm(newpath, normBase)
	if err != nil {
		return "", err
	}
	return newpath, nil
}

${this.title}

Code Editor : symlink_windows.go