summaryrefslogtreecommitdiff
path: root/src/pkg/bytes/bytes.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/bytes/bytes.go')
-rw-r--r--src/pkg/bytes/bytes.go97
1 files changed, 48 insertions, 49 deletions
diff --git a/src/pkg/bytes/bytes.go b/src/pkg/bytes/bytes.go
index 30ac4580b..103a89674 100644
--- a/src/pkg/bytes/bytes.go
+++ b/src/pkg/bytes/bytes.go
@@ -17,31 +17,31 @@ func Compare(a, b []byte) int {
for i := 0; i < len(a) && i < len(b); i++ {
switch {
case a[i] > b[i]:
- return 1
+ return 1;
case a[i] < b[i]:
- return -1
+ return -1;
}
}
switch {
case len(a) < len(b):
- return -1
+ return -1;
case len(a) > len(b):
- return 1
+ return 1;
}
- return 0
+ return 0;
}
// Equal returns a boolean reporting whether a == b.
func Equal(a, b []byte) bool {
if len(a) != len(b) {
- return false
+ return false;
}
for i := 0; i < len(a); i++ {
if a[i] != b[i] {
- return false
+ return false;
}
}
- return true
+ return true;
}
// Copy copies bytes from src to dst,
@@ -53,9 +53,9 @@ func Copy(dst, src []byte) int {
src = src[0:len(dst)];
}
for i, x := range src {
- dst[i] = x
+ dst[i] = x;
}
- return len(src)
+ return len(src);
}
// explode splits s into an array of UTF-8 sequences, one per Unicode character (still arrays of bytes),
@@ -71,45 +71,45 @@ func explode(s []byte, n int) [][]byte {
if na+1 >= n {
a[na] = s;
na++;
- break
+ break;
}
_, size = utf8.DecodeRune(s);
a[na] = s[0:size];
s = s[size:len(s)];
na++;
}
- return a[0:na]
+ return a[0:na];
}
// Count counts the number of non-overlapping instances of sep in s.
func Count(s, sep []byte) int {
if len(sep) == 0 {
- return utf8.RuneCount(s)+1
+ return utf8.RuneCount(s) + 1;
}
c := sep[0];
n := 0;
for i := 0; i+len(sep) <= len(s); i++ {
- if s[i] == c && (len(sep) == 1 || Equal(s[i:i+len(sep)], sep)) {
+ if s[i] == c && (len(sep) == 1 || Equal(s[i : i+len(sep)], sep)) {
n++;
- i += len(sep)-1
+ 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 []byte) int {
n := len(sep);
if n == 0 {
- return 0
+ return 0;
}
c := sep[0];
for i := 0; i+n <= len(s); i++ {
- if s[i] == c && (n == 1 || Equal(s[i:i+n], sep)) {
- return i
+ if s[i] == c && (n == 1 || Equal(s[i : i+n], sep)) {
+ return i;
}
}
- return -1
+ return -1;
}
// Split splits the array s around each instance of sep, returning an array of subarrays of s.
@@ -117,7 +117,7 @@ func Index(s, sep []byte) int {
// If n > 0, split Splits s into at most n subarrays; the last subarray will contain an unsplit remainder.
func Split(s, sep []byte, n int) [][]byte {
if len(sep) == 0 {
- return explode(s, n)
+ return explode(s, n);
}
if n <= 0 {
n = Count(s, sep) + 1;
@@ -127,7 +127,7 @@ func Split(s, sep []byte, n int) [][]byte {
a := make([][]byte, n);
na := 0;
for i := 0; i+len(sep) <= len(s) && na+1 < n; i++ {
- if s[i] == c && (len(sep) == 1 || Equal(s[i:i+len(sep)], sep)) {
+ if s[i] == c && (len(sep) == 1 || Equal(s[i : i+len(sep)], sep)) {
a[na] = s[start:i];
na++;
start = i+len(sep);
@@ -135,21 +135,21 @@ func Split(s, sep []byte, n int) [][]byte {
}
}
a[na] = s[start:len(s)];
- return a[0:na+1]
+ return a[0 : na+1];
}
// Join concatenates the elements of a to create a single byte array. The separator
// sep is placed between elements in the resulting array.
func Join(a [][]byte, sep []byte) []byte {
if len(a) == 0 {
- return []byte{}
+ return []byte{};
}
if len(a) == 1 {
- return a[0]
+ 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])
+ n += len(a[i]);
}
b := make([]byte, n);
@@ -158,27 +158,27 @@ func Join(a [][]byte, sep []byte) []byte {
s := a[i];
for j := 0; j < len(s); j++ {
b[bp] = s[j];
- bp++
+ bp++;
}
- if i + 1 < len(a) {
+ if i+1 < len(a) {
s = sep;
for j := 0; j < len(s); j++ {
b[bp] = s[j];
- bp++
+ bp++;
}
}
}
- return b
+ return b;
}
// HasPrefix tests whether the byte array s begins with prefix.
func HasPrefix(s, prefix []byte) bool {
- return len(s) >= len(prefix) && Equal(s[0:len(prefix)], prefix)
+ return len(s) >= len(prefix) && Equal(s[0:len(prefix)], prefix);
}
// HasSuffix tests whether the byte array s ends with suffix.
func HasSuffix(s, suffix []byte) bool {
- return len(s) >= len(suffix) && Equal(s[len(s)-len(suffix):len(s)], suffix)
+ return len(s) >= len(suffix) && Equal(s[len(s)-len(suffix) : len(s)], suffix);
}
// Map returns a copy of the byte array s with all its characters modified
@@ -188,7 +188,7 @@ func Map(mapping func(rune int) int, s []byte) []byte {
// 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
+ nbytes := 0; // number of bytes encoded in b
b := make([]byte, maxbytes);
for i := 0; i < len(s); {
wid := 1;
@@ -204,7 +204,7 @@ func Map(mapping func(rune int) int, s []byte) []byte {
maxbytes = maxbytes*2 + utf8.UTFMax;
nb := make([]byte, maxbytes);
for i, c := range b[0:nbytes] {
- nb[i] = c
+ nb[i] = c;
}
b = nb;
}
@@ -216,17 +216,17 @@ func Map(mapping func(rune int) int, s []byte) []byte {
// ToUpper returns a copy of the byte array s with all Unicode letters mapped to their upper case.
func ToUpper(s []byte) []byte {
- return Map(unicode.ToUpper, s)
+ return Map(unicode.ToUpper, s);
}
// ToUpper returns a copy of the byte array s with all Unicode letters mapped to their lower case.
func ToLower(s []byte) []byte {
- return Map(unicode.ToLower, s)
+ return Map(unicode.ToLower, s);
}
// ToTitle returns a copy of the byte array s with all Unicode letters mapped to their title case.
func Title(s []byte) []byte {
- return Map(unicode.ToTitle, s)
+ return Map(unicode.ToTitle, s);
}
// Trim returns a slice of the string s, with all leading and trailing white space
@@ -237,7 +237,7 @@ func TrimSpace(s []byte) []byte {
wid := 1;
rune := int(s[start]);
if rune >= utf8.RuneSelf {
- rune, wid = utf8.DecodeRune(s[start:end])
+ rune, wid = utf8.DecodeRune(s[start:end]);
}
if !unicode.IsSpace(rune) {
break;
@@ -249,12 +249,11 @@ func TrimSpace(s []byte) []byte {
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++ {
- }
+ for wid = 2; start <= end-wid && !utf8.RuneStart(s[end-wid]); wid++ {}
if start > end-wid { // invalid UTF-8 sequence; stop processing
- return s[start:end]
+ return s[start:end];
}
- rune, wid = utf8.DecodeRune(s[end-wid:end]);
+ rune, wid = utf8.DecodeRune(s[end-wid : end]);
}
if !unicode.IsSpace(rune) {
break;
@@ -268,7 +267,7 @@ func TrimSpace(s []byte) []byte {
// Heuristic: Scale by 50% to give n log n time.
func resize(n int) int {
if n < 16 {
- n = 16
+ n = 16;
}
return n + n/2;
}
@@ -279,14 +278,14 @@ func resize(n int) int {
func Add(s, t []byte) []byte {
lens := len(s);
lent := len(t);
- if lens + lent <= cap(s) {
- s = s[0:lens+lent];
+ if lens+lent <= cap(s) {
+ s = s[0 : lens+lent];
} else {
news := make([]byte, lens+lent, resize(lens+lent));
Copy(news, s);
s = news;
}
- Copy(s[lens:lens+lent], t);
+ Copy(s[lens : lens+lent], t);
return s;
}
@@ -295,8 +294,8 @@ func Add(s, t []byte) []byte {
// new array is allocated and returned.
func AddByte(s []byte, t byte) []byte {
lens := len(s);
- if lens + 1 <= cap(s) {
- s = s[0:lens+1];
+ if lens+1 <= cap(s) {
+ s = s[0 : lens+1];
} else {
news := make([]byte, lens+1, resize(lens+1));
Copy(news, s);
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-09 07:08:10 +0000