code review 1326042: changes &x -> x[0:] for array to slice conversion

src/pkg/encoding/git85/git.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 git85 implements the radix 85 data encoding
 // used in the Git version control system.
 package git85
 
 import (
         "bytes"
@@ skipping 159 matching lines @@
                 var i int
                 for i = 0; i < len(p) && e.nbuf < 52; i++ {
                         e.buf[e.nbuf] = p[i]
                         e.nbuf++
                 }
                 n += i
                 p = p[i:]
                 if e.nbuf < 52 {
                         return
                 }
-                nout := Encode(&e.out, &e.buf)
+                nout := Encode(e.out[0:], e.buf[0:])
                 if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
                         return n, e.err
                 }
                 e.nbuf = 0
         }
 
         // Large interior chunks.
         for len(p) >= 52 {
                 nn := len(e.out) / (1 + 52/4*5 + 1) * 52
                 if nn > len(p) {
                         nn = len(p) / 52 * 52
                 }
                 if nn > 0 {
-                        nout := Encode(&e.out, p[0:nn])
+                        nout := Encode(e.out[0:], p[0:nn])
                         if _, e.err = e.w.Write(e.out[0:nout]); e.err != nil {
                                 return n, e.err
                         }
                 }
                 n += nn
                 p = p[nn:]
         }
 
         // Trailing fringe.
         for i := 0; i < len(p); i++ {
                 e.buf[i] = p[i]
         }
         e.nbuf = len(p)
         n += len(p)
         return
 }
 
 func (e *encoder) Close() os.Error {
         // If there's anything left in the buffer, flush it out
         if e.err == nil && e.nbuf > 0 {
-                nout := Encode(&e.out, e.buf[0:e.nbuf])
+                nout := Encode(e.out[0:], e.buf[0:e.nbuf])
                 e.nbuf = 0
                 _, e.err = e.w.Write(e.out[0:nout])
         }
         return e.err
 }
 
 // NewDecoder returns a new Git base85 stream decoder.
 func NewDecoder(r io.Reader) io.Reader { return &decoder{r: r} }
 
 type decoder struct {
@@ skipping 32 matching lines @@
                 // Read and decode more input.
                 var nn int
                 nn, d.readErr = d.r.Read(d.buf[d.nbuf:])
                 d.nbuf += nn
 
                 // Send complete lines to Decode.
                 nl := bytes.LastIndex(d.buf[0:d.nbuf], newline)
                 if nl < 0 {
                         continue
                 }
-                nn, d.err = Decode(&d.outbuf, d.buf[0:nl+1])
+                nn, d.err = Decode(d.outbuf[0:], d.buf[0:nl+1])
                 if e, ok := d.err.(CorruptInputError); ok {
                         d.err = CorruptInputError(int64(e) + d.off)
                 }
                 d.out = d.outbuf[0:nn]
-                d.nbuf = copy(&d.buf, d.buf[nl+1:d.nbuf])
+                d.nbuf = copy(d.buf[0:], d.buf[nl+1:d.nbuf])
                 d.off += int64(nl + 1)
         }
         panic("unreacahable")
 }