bufio: Write and WriteString cleanup

Write never writes less than the buffer size and WriteString takes advantage
of the copy built-in to improve write efficiency.

R=rsc, ality, rog
CC=golang-dev
https://golang.org/cl/4344060

diff --git a/src/pkg/bufio/bufio.go b/src/pkg/bufio/bufio.go
index eae5c5ce9754e094ee85e1a92d074ba26d976e88..cd08be31b6ac93f65eda92cd9cd539f14190c4f1 100644 (file)
--- a/src/pkg/bufio/bufio.go
+++ b/src/pkg/bufio/bufio.go
@@ -415,38 +415,27 @@ func (b *Writer) Buffered() int { return b.n }
 // If nn < len(p), it also returns an error explaining
 // why the write is short.
 func (b *Writer) Write(p []byte) (nn int, err os.Error) {
-       if b.err != nil {
-               return 0, b.err
-       }
-       nn = 0
-       for len(p) > 0 {
-               n := b.Available()
-               if n <= 0 {
-                       if b.Flush(); b.err != nil {
-                               break
-                       }
-                       n = b.Available()
-               }
-               if b.Buffered() == 0 && len(p) >= len(b.buf) {
+       for len(p) > b.Available() && b.err == nil {
+               var n int
+               if b.Buffered() == 0 {
                        // Large write, empty buffer.
                        // Write directly from p to avoid copy.
                        n, b.err = b.wr.Write(p)
-                       nn += n
-                       p = p[n:]
-                       if b.err != nil {
-                               break
-                       }
-                       continue
-               }
-               if n > len(p) {
-                       n = len(p)
+               } else {
+                       n = copy(b.buf[b.n:], p)
+                       b.n += n
+                       b.Flush()
                }
-               copy(b.buf[b.n:b.n+n], p[0:n])
-               b.n += n
                nn += n
                p = p[n:]
        }
-       return nn, b.err
+       if b.err != nil {
+               return nn, b.err
+       }
+       n := copy(b.buf[b.n:], p)
+       b.n += n
+       nn += n
+       return nn, nil
 }
 
 // WriteByte writes a single byte.
@@ -496,24 +485,21 @@ func (b *Writer) WriteRune(rune int) (size int, err os.Error) {
 // If the count is less than len(s), it also returns an error explaining
 // why the write is short.
 func (b *Writer) WriteString(s string) (int, os.Error) {
-       if b.err != nil {
-               return 0, b.err
-       }
-       // Common case, worth making fast.
-       if b.Available() >= len(s) || len(b.buf) >= len(s) && b.Flush() == nil {
-               for i := 0; i < len(s); i++ { // loop over bytes, not runes.
-                       b.buf[b.n] = s[i]
-                       b.n++
-               }
-               return len(s), nil
+       nn := 0
+       for len(s) > b.Available() && b.err == nil {
+               n := copy(b.buf[b.n:], s)
+               b.n += n
+               nn += n
+               s = s[n:]
+               b.Flush()
        }
-       for i := 0; i < len(s); i++ { // loop over bytes, not runes.
-               b.WriteByte(s[i])
-               if b.err != nil {
-                       return i, b.err
-               }
+       if b.err != nil {
+               return nn, b.err
        }
-       return len(s), nil
+       n := copy(b.buf[b.n:], s)
+       b.n += n
+       nn += n
+       return nn, nil
 }
 
 // buffered input and output