mirror of
https://github.com/golang/go.git
synced 2024-09-30 23:07:22 +00:00
60ce95d7a1
as a reminder, the old conversion was that you could write var arr [10]byte; var slice []byte; slice = arr; but now you have to write slice = &arr; the change eliminates an implicit &, so that the only implicit &s left are in the . operator and in string(arr). also, removed utf8.EncodeRuneToString in favor of string(rune). R=r DELTA=83 (1 added, 23 deleted, 59 changed) OCL=27531 CL=27534
92 lines
1.5 KiB
Go
92 lines
1.5 KiB
Go
// 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 Utils
|
|
|
|
|
|
func BaseName(s string) string {
|
|
// TODO this is not correct for non-ASCII strings!
|
|
i := len(s) - 1;
|
|
for i >= 0 && s[i] != '/' {
|
|
if s[i] > 128 {
|
|
panic("non-ASCII string");
|
|
}
|
|
i--;
|
|
}
|
|
return s[i + 1 : len(s)];
|
|
}
|
|
|
|
|
|
func cleanPath(s string) string {
|
|
for i := 0; i < len(s); i++ {
|
|
if s[i] == '/' {
|
|
i++;
|
|
j := i;
|
|
for j < len(s) && s[j] == '/' {
|
|
j++;
|
|
}
|
|
if j > i { // more then one '/'
|
|
return s[0 : i] + cleanPath(s[j : len(s)]);
|
|
}
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
// Reduce sequences of multiple '/'s into a single '/' and
|
|
// strip any trailing '/' (may result in the empty string).
|
|
func SanitizePath(s string) string {
|
|
s = cleanPath(s);
|
|
if s[len(s)-1] == '/' { // strip trailing '/'
|
|
s = s[0 : len(s)-1];
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
func Contains(s, sub string, pos int) bool {
|
|
end := pos + len(sub);
|
|
return pos >= 0 && end <= len(s) && s[pos : end] == sub;
|
|
}
|
|
|
|
|
|
func TrimExt(s, ext string) string {
|
|
i := len(s) - len(ext);
|
|
if i >= 0 && s[i : len(s)] == ext {
|
|
s = s[0 : i];
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
func IntToString(x, base int) string {
|
|
x0 := x;
|
|
if x < 0 {
|
|
x = -x;
|
|
if x < 0 {
|
|
panic("smallest int not handled");
|
|
}
|
|
} else if x == 0 {
|
|
return "0";
|
|
}
|
|
|
|
// x > 0
|
|
hex := "0123456789ABCDEF";
|
|
var buf [32] byte;
|
|
i := len(buf);
|
|
for x > 0 {
|
|
i--;
|
|
buf[i] = hex[x % base];
|
|
x /= base;
|
|
}
|
|
|
|
if x0 < 0 {
|
|
i--;
|
|
buf[i] = '-';
|
|
}
|
|
|
|
return string(buf[i : len(buf)]);
|
|
}
|