code review 1704044: strings and bytes.Split: make count of 0 mean 0, not in...

src/pkg/bytes/bytes.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.
 
 // The bytes package implements functions for the manipulation of byte slices.
 // Analagous to the facilities of the strings package.
 package bytes
 
 import (
         "unicode"
@@ skipping 136 matching lines @@
                                 }
                         }
                 }
         }
         return -1
 }
 
 // Generic split: splits after each instance of sep,
 // including sepSave bytes of sep in the subarrays.
 func genSplit(s, sep []byte, sepSave, n int) [][]byte {
+        if n == 0 {
+                return nil
+        }
         if len(sep) == 0 {
                 return explode(s, n)
         }
         if n <= 0 {
                 n = Count(s, sep) + 1
         }
         c := sep[0]
         start := 0
         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)) {
                         a[na] = s[start : i+sepSave]
                         na++
                         start = i + len(sep)
                         i += len(sep) - 1
                 }
         }
         a[na] = s[start:]
         return a[0 : na+1]
 }
 
 // Split splits the array s around each instance of sep, returning an array of subarrays of s.
 // If sep is empty, Split splits s after each UTF-8 sequence.
-// If n > 0, Split splits s into at most n subarrays; the last subarray will contain an unsplit remainder.
+// If n >= 0, Split splits s into at most n subarrays; the last subarray will contain an unsplit remainder.
+// Thus if n == 0, the result will ne nil.
 func Split(s, sep []byte, n int) [][]byte { return genSplit(s, sep, 0, n) }
 
 // SplitAfter splits the array s after each instance of sep, returning an array of subarrays of s.
 // If sep is empty, SplitAfter splits s after each UTF-8 sequence.
-// If n > 0, SplitAfter splits s into at most n subarrays; the last subarray will contain an
+// If n >= 0, SplitAfter splits s into at most n subarrays; the last subarray will contain an
 // unsplit remainder.
+// Thus if n == 0, the result will ne nil.
 func SplitAfter(s, sep []byte, n int) [][]byte {
         return genSplit(s, sep, len(sep), n)
 }
 
 // Fields splits the array s around each instance of one or more consecutive white space
 // characters, returning a slice of subarrays of s or an empty list if s contains only white space.
 func Fields(s []byte) [][]byte {
         n := 0
         inField := false
         for i := 0; i < len(s); {
@@ skipping 260 matching lines @@
                 r, l := utf8.DecodeRune(s)
                 t[i] = r
                 i++
                 s = s[l:]
         }
         return t
 }
 
 // Replace returns a copy of the slice s with the first n
 // non-overlapping instances of old replaced by new.
-// If n <= 0, there is no limit on the number of replacements.
+// If n < 0, there is no limit on the number of replacements.
 func Replace(s, old, new []byte, n int) []byte {
+        if n == 0 {
+                return s // avoid allocation
+        }
         // Compute number of replacements.
         if m := Count(s, old); m == 0 {
                 return s // avoid allocation
         } else if n <= 0 || m < n {
                 n = m
         }
 
         // Apply replacements to buffer.
         t := make([]byte, len(s)+n*(len(new)-len(old)))
         w := 0
         start := 0
         for i := 0; i < n; i++ {
                 j := start
                 if len(old) == 0 {
                         if i > 0 {
                                 _, wid := utf8.DecodeRune(s[start:])
                                 j += wid
                         }
                 } else {
                         j += Index(s[start:], old)
                 }
                 w += copy(t[w:], s[start:j])
                 w += copy(t[w:], new)
                 start = j + len(old)
         }
         w += copy(t[w:], s[start:])
         return t[0:w]
 }