mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
1) Change default gofmt default settings for
parsing and printing to new syntax. Use -oldparser to parse the old syntax, use -oldprinter to print the old syntax. 2) Change default gofmt formatting settings to use tabs for indentation only and to use spaces for alignment. This will make the code alignment insensitive to an editor's tabwidth. Use -spaces=false to use tabs for alignment. 3) Manually changed src/exp/parser/parser_test.go so that it doesn't try to parse the parser's source files using the old syntax (they have new syntax now). 4) gofmt -w src misc test/bench 4th set of files. R=rsc CC=golang-dev https://golang.org/cl/180049
This commit is contained in:
Robert Griesemer
parent
a3d1045fb7
commit
d65a5cce89
119 changed files with 14325 additions and 14325 deletions
|
|
@ -6,8 +6,8 @@
|
|||
package strings
|
||||
|
||||
import (
|
||||
"unicode";
|
||||
"utf8";
|
||||
"unicode"
|
||||
"utf8"
|
||||
)
|
||||
|
||||
// explode splits s into an array of UTF-8 sequences, one per Unicode character (still strings) up to a maximum of n (n <= 0 means no limit).
|
||||
|
|
@ -16,21 +16,21 @@ func explode(s string, n int) []string {
|
|||
if n <= 0 {
|
||||
n = len(s)
|
||||
}
|
||||
a := make([]string, n);
|
||||
var size, rune int;
|
||||
na := 0;
|
||||
a := make([]string, n)
|
||||
var size, rune int
|
||||
na := 0
|
||||
for len(s) > 0 {
|
||||
if na+1 >= n {
|
||||
a[na] = s;
|
||||
na++;
|
||||
break;
|
||||
a[na] = s
|
||||
na++
|
||||
break
|
||||
}
|
||||
rune, size = utf8.DecodeRuneInString(s);
|
||||
s = s[size:];
|
||||
a[na] = string(rune);
|
||||
na++;
|
||||
rune, size = utf8.DecodeRuneInString(s)
|
||||
s = s[size:]
|
||||
a[na] = string(rune)
|
||||
na++
|
||||
}
|
||||
return a[0:na];
|
||||
return a[0:na]
|
||||
}
|
||||
|
||||
// Count counts the number of non-overlapping instances of sep in s.
|
||||
|
|
@ -38,24 +38,24 @@ func Count(s, sep string) int {
|
|||
if sep == "" {
|
||||
return utf8.RuneCountInString(s) + 1
|
||||
}
|
||||
c := sep[0];
|
||||
n := 0;
|
||||
c := sep[0]
|
||||
n := 0
|
||||
for i := 0; i+len(sep) <= len(s); i++ {
|
||||
if s[i] == c && (len(sep) == 1 || s[i:i+len(sep)] == sep) {
|
||||
n++;
|
||||
i += len(sep) - 1;
|
||||
n++
|
||||
i += len(sep) - 1
|
||||
}
|
||||
}
|
||||
return n;
|
||||
return n
|
||||
}
|
||||
|
||||
// Index returns the index of the first instance of sep in s, or -1 if sep is not present in s.
|
||||
func Index(s, sep string) int {
|
||||
n := len(sep);
|
||||
n := len(sep)
|
||||
if n == 0 {
|
||||
return 0
|
||||
}
|
||||
c := sep[0];
|
||||
c := sep[0]
|
||||
if n == 1 {
|
||||
// special case worth making fast
|
||||
for i := 0; i < len(s); i++ {
|
||||
|
|
@ -63,23 +63,23 @@ func Index(s, sep string) int {
|
|||
return i
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
return -1
|
||||
}
|
||||
for i := 0; i+n <= len(s); i++ {
|
||||
if s[i] == c && (n == 1 || s[i:i+n] == sep) {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
return -1
|
||||
}
|
||||
|
||||
// LastIndex returns the index of the last instance of sep in s, or -1 if sep is not present in s.
|
||||
func LastIndex(s, sep string) int {
|
||||
n := len(sep);
|
||||
n := len(sep)
|
||||
if n == 0 {
|
||||
return len(s)
|
||||
}
|
||||
c := sep[0];
|
||||
c := sep[0]
|
||||
if n == 1 {
|
||||
// special case worth making fast
|
||||
for i := len(s) - 1; i >= 0; i-- {
|
||||
|
|
@ -87,14 +87,14 @@ func LastIndex(s, sep string) int {
|
|||
return i
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
return -1
|
||||
}
|
||||
for i := len(s) - n; i >= 0; i-- {
|
||||
if s[i] == c && (n == 1 || s[i:i+n] == sep) {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
return -1
|
||||
}
|
||||
|
||||
// Generic split: splits after each instance of sep,
|
||||
|
|
@ -106,26 +106,26 @@ func genSplit(s, sep string, sepSave, n int) []string {
|
|||
if n <= 0 {
|
||||
n = Count(s, sep) + 1
|
||||
}
|
||||
c := sep[0];
|
||||
start := 0;
|
||||
a := make([]string, n);
|
||||
na := 0;
|
||||
c := sep[0]
|
||||
start := 0
|
||||
a := make([]string, n)
|
||||
na := 0
|
||||
for i := 0; i+len(sep) <= len(s) && na+1 < n; i++ {
|
||||
if s[i] == c && (len(sep) == 1 || s[i:i+len(sep)] == sep) {
|
||||
a[na] = s[start : i+sepSave];
|
||||
na++;
|
||||
start = i + len(sep);
|
||||
i += len(sep) - 1;
|
||||
a[na] = s[start : i+sepSave]
|
||||
na++
|
||||
start = i + len(sep)
|
||||
i += len(sep) - 1
|
||||
}
|
||||
}
|
||||
a[na] = s[start:];
|
||||
return a[0 : na+1];
|
||||
a[na] = s[start:]
|
||||
return a[0 : na+1]
|
||||
}
|
||||
|
||||
// Split splits the string s around each instance of sep, returning an array of substrings of s.
|
||||
// If sep is empty, Split splits s after each UTF-8 sequence.
|
||||
// If n > 0, Split splits s into at most n substrings; the last substring will be the unsplit remainder.
|
||||
func Split(s, sep string, n int) []string { return genSplit(s, sep, 0, n) }
|
||||
func Split(s, sep string, n int) []string { return genSplit(s, sep, 0, n) }
|
||||
|
||||
// SplitAfter splits the string s after each instance of sep, returning an array of substrings of s.
|
||||
// If sep is empty, SplitAfter splits s after each UTF-8 sequence.
|
||||
|
|
@ -143,28 +143,28 @@ func Join(a []string, sep string) string {
|
|||
if len(a) == 1 {
|
||||
return a[0]
|
||||
}
|
||||
n := len(sep) * (len(a) - 1);
|
||||
n := len(sep) * (len(a) - 1)
|
||||
for i := 0; i < len(a); i++ {
|
||||
n += len(a[i])
|
||||
}
|
||||
|
||||
b := make([]byte, n);
|
||||
bp := 0;
|
||||
b := make([]byte, n)
|
||||
bp := 0
|
||||
for i := 0; i < len(a); i++ {
|
||||
s := a[i];
|
||||
s := a[i]
|
||||
for j := 0; j < len(s); j++ {
|
||||
b[bp] = s[j];
|
||||
bp++;
|
||||
b[bp] = s[j]
|
||||
bp++
|
||||
}
|
||||
if i+1 < len(a) {
|
||||
s = sep;
|
||||
s = sep
|
||||
for j := 0; j < len(s); j++ {
|
||||
b[bp] = s[j];
|
||||
bp++;
|
||||
b[bp] = s[j]
|
||||
bp++
|
||||
}
|
||||
}
|
||||
}
|
||||
return string(b);
|
||||
return string(b)
|
||||
}
|
||||
|
||||
// HasPrefix tests whether the string s begins with prefix.
|
||||
|
|
@ -184,105 +184,105 @@ func Map(mapping func(rune int) int, s string) string {
|
|||
// In the worst case, the string can grow when mapped, making
|
||||
// things unpleasant. But it's so rare we barge in assuming it's
|
||||
// fine. It could also shrink but that falls out naturally.
|
||||
maxbytes := len(s); // length of b
|
||||
nbytes := 0; // number of bytes encoded in b
|
||||
b := make([]byte, maxbytes);
|
||||
maxbytes := len(s) // length of b
|
||||
nbytes := 0 // number of bytes encoded in b
|
||||
b := make([]byte, maxbytes)
|
||||
for _, c := range s {
|
||||
rune := mapping(c);
|
||||
rune := mapping(c)
|
||||
if rune >= 0 {
|
||||
wid := 1;
|
||||
wid := 1
|
||||
if rune >= utf8.RuneSelf {
|
||||
wid = utf8.RuneLen(rune)
|
||||
}
|
||||
if nbytes+wid > maxbytes {
|
||||
// Grow the buffer.
|
||||
maxbytes = maxbytes*2 + utf8.UTFMax;
|
||||
nb := make([]byte, maxbytes);
|
||||
maxbytes = maxbytes*2 + utf8.UTFMax
|
||||
nb := make([]byte, maxbytes)
|
||||
for i, c := range b[0:nbytes] {
|
||||
nb[i] = c
|
||||
}
|
||||
b = nb;
|
||||
b = nb
|
||||
}
|
||||
nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes]);
|
||||
nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes])
|
||||
}
|
||||
}
|
||||
return string(b[0:nbytes]);
|
||||
return string(b[0:nbytes])
|
||||
}
|
||||
|
||||
// Repeat returns a new string consisting of count copies of the string s.
|
||||
func Repeat(s string, count int) string {
|
||||
b := make([]byte, len(s)*count);
|
||||
bp := 0;
|
||||
b := make([]byte, len(s)*count)
|
||||
bp := 0
|
||||
for i := 0; i < count; i++ {
|
||||
for j := 0; j < len(s); j++ {
|
||||
b[bp] = s[j];
|
||||
bp++;
|
||||
b[bp] = s[j]
|
||||
bp++
|
||||
}
|
||||
}
|
||||
return string(b);
|
||||
return string(b)
|
||||
}
|
||||
|
||||
|
||||
// ToUpper returns a copy of the string s with all Unicode letters mapped to their upper case.
|
||||
func ToUpper(s string) string { return Map(unicode.ToUpper, s) }
|
||||
func ToUpper(s string) string { return Map(unicode.ToUpper, s) }
|
||||
|
||||
// ToLower returns a copy of the string s with all Unicode letters mapped to their lower case.
|
||||
func ToLower(s string) string { return Map(unicode.ToLower, s) }
|
||||
func ToLower(s string) string { return Map(unicode.ToLower, s) }
|
||||
|
||||
// ToTitle returns a copy of the string s with all Unicode letters mapped to their title case.
|
||||
func ToTitle(s string) string { return Map(unicode.ToTitle, s) }
|
||||
func ToTitle(s string) string { return Map(unicode.ToTitle, s) }
|
||||
|
||||
// Trim returns a slice of the string s, with all leading and trailing white space
|
||||
// removed, as defined by Unicode.
|
||||
func TrimSpace(s string) string {
|
||||
start, end := 0, len(s);
|
||||
start, end := 0, len(s)
|
||||
for start < end {
|
||||
wid := 1;
|
||||
rune := int(s[start]);
|
||||
wid := 1
|
||||
rune := int(s[start])
|
||||
if rune >= utf8.RuneSelf {
|
||||
rune, wid = utf8.DecodeRuneInString(s[start:end])
|
||||
}
|
||||
if !unicode.IsSpace(rune) {
|
||||
break
|
||||
}
|
||||
start += wid;
|
||||
start += wid
|
||||
}
|
||||
for start < end {
|
||||
wid := 1;
|
||||
rune := int(s[end-1]);
|
||||
wid := 1
|
||||
rune := int(s[end-1])
|
||||
if rune >= utf8.RuneSelf {
|
||||
// Back up carefully looking for beginning of rune. Mustn't pass start.
|
||||
for wid = 2; start <= end-wid && !utf8.RuneStart(s[end-wid]); wid++ {
|
||||
}
|
||||
if start > end-wid { // invalid UTF-8 sequence; stop processing
|
||||
if start > end-wid { // invalid UTF-8 sequence; stop processing
|
||||
return s[start:end]
|
||||
}
|
||||
rune, wid = utf8.DecodeRuneInString(s[end-wid : end]);
|
||||
rune, wid = utf8.DecodeRuneInString(s[end-wid : end])
|
||||
}
|
||||
if !unicode.IsSpace(rune) {
|
||||
break
|
||||
}
|
||||
end -= wid;
|
||||
end -= wid
|
||||
}
|
||||
return s[start:end];
|
||||
return s[start:end]
|
||||
}
|
||||
|
||||
// Bytes returns a new slice containing the bytes in s.
|
||||
func Bytes(s string) []byte {
|
||||
b := make([]byte, len(s));
|
||||
b := make([]byte, len(s))
|
||||
for i := 0; i < len(s); i++ {
|
||||
b[i] = s[i]
|
||||
}
|
||||
return b;
|
||||
return b
|
||||
}
|
||||
|
||||
// Runes returns a slice of runes (Unicode code points) equivalent to the string s.
|
||||
func Runes(s string) []int {
|
||||
t := make([]int, utf8.RuneCountInString(s));
|
||||
i := 0;
|
||||
t := make([]int, utf8.RuneCountInString(s))
|
||||
i := 0
|
||||
for _, r := range s {
|
||||
t[i] = r;
|
||||
i++;
|
||||
t[i] = r
|
||||
i++
|
||||
}
|
||||
return t;
|
||||
return t
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue