code review 224062: strings: delete Runes, Bytes

src/pkg/archive/tar/writer.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 tar
 
 // TODO(dsymonds):
 // - catch more errors (no first header, write after close, etc.)
 
 import (
         "io"
         "os"
         "strconv"
-        "strings"
 )
 
 var (
         ErrWriteTooLong    = os.NewError("write too long")
         ErrFieldTooLong    = os.NewError("header field too long")
         ErrWriteAfterClose = os.NewError("write after close")
 )
 
 // A Writer provides sequential writing of a tar archive in POSIX.1 format.
 // A tar archive consists of a sequence of files.
@@ skipping 40 matching lines @@
 }
 
 // Write s into b, terminating it with a NUL if there is room.
 func (tw *Writer) cString(b []byte, s string) {
         if len(s) > len(b) {
                 if tw.err == nil {
                         tw.err = ErrFieldTooLong
                 }
                 return
         }
-        for i, ch := range strings.Bytes(s) {
+        for i, ch := range []byte(s) {
                 b[i] = ch
         }
         if len(s) < len(b) {
                 b[len(s)] = 0
         }
 }
 
 // Encode x as an octal ASCII string and write it into b with leading zeros.
 func (tw *Writer) octal(b []byte, x int64) {
         s := strconv.Itob64(x, 8)
@@ skipping 35 matching lines @@
                 return tw.err
         }
 
         tw.nb = int64(hdr.Size)
         tw.pad = -tw.nb & (blockSize - 1) // blockSize is a power of two
 
         header := make([]byte, blockSize)
         s := slicer(header)
 
         // TODO(dsymonds): handle names longer than 100 chars
-        copy(s.next(100), strings.Bytes(hdr.Name))
+        copy(s.next(100), []byte(hdr.Name))
 
-        tw.octal(s.next(8), hdr.Mode)                 // 100:108
-        tw.numeric(s.next(8), hdr.Uid)                // 108:116
-        tw.numeric(s.next(8), hdr.Gid)                // 116:124
-        tw.numeric(s.next(12), hdr.Size)              // 124:136
-        tw.numeric(s.next(12), hdr.Mtime)             // 136:148
-        s.next(8)                                     // chksum (148:156)
-        s.next(1)[0] = hdr.Typeflag                   // 156:157
-        s.next(100)                                   // linkname (157:257)
-        copy(s.next(8), strings.Bytes("ustar\x0000")) // 257:265
-        tw.cString(s.next(32), hdr.Uname)             // 265:297
-        tw.cString(s.next(32), hdr.Gname)             // 297:329
-        tw.numeric(s.next(8), hdr.Devmajor)           // 329:337
-        tw.numeric(s.next(8), hdr.Devminor)           // 337:345
+        tw.octal(s.next(8), hdr.Mode)          // 100:108
+        tw.numeric(s.next(8), hdr.Uid)         // 108:116
+        tw.numeric(s.next(8), hdr.Gid)         // 116:124
+        tw.numeric(s.next(12), hdr.Size)       // 124:136
+        tw.numeric(s.next(12), hdr.Mtime)      // 136:148
+        s.next(8)                              // chksum (148:156)
+        s.next(1)[0] = hdr.Typeflag            // 156:157
+        s.next(100)                            // linkname (157:257)
+        copy(s.next(8), []byte("ustar\x0000")) // 257:265
+        tw.cString(s.next(32), hdr.Uname)      // 265:297
+        tw.cString(s.next(32), hdr.Gname)      // 297:329
+        tw.numeric(s.next(8), hdr.Devmajor)    // 329:337
+        tw.numeric(s.next(8), hdr.Devminor)    // 337:345
 
         // Use the GNU magic instead of POSIX magic if we used any GNU extensions.
         if tw.usedBinary {
-                copy(header[257:265], strings.Bytes("ustar  \x00"))
+                copy(header[257:265], []byte("ustar  \x00"))
         }
 
         // The chksum field is terminated by a NUL and a space.
         // This is different from the other octal fields.
         chksum, _ := checksum(header)
         tw.octal(header[148:155], chksum)
         header[155] = ' '
 
         if tw.err != nil {
                 // problem with header; probably integer too big for a field.
@@ skipping 39 matching lines @@
 
         // trailer: two zero blocks
         for i := 0; i < 2; i++ {
                 _, tw.err = tw.w.Write(zeroBlock)
                 if tw.err != nil {
                         break
                 }
         }
         return tw.err
 }