code review 156115: gofmt -r 'α[β:len(α)] -> α[β:]' -w src/cmd src/pkg

src/pkg/encoding/base64/base64.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 base64 implements base64 encoding as specified by RFC 4648.
 package base64
 
 import (
         "io";
         "os";
@@ skipping 83 matching lines @@
 
                 // Pad the final quantum
                 if len(src) < 3 {
                         dst[3] = '=';
                         if len(src) < 2 {
                                 dst[2] = '='
                         }
                         break;
                 }
 
-                src = src[3:len(src)];
-                dst = dst[4:len(dst)];
+                src = src[3:];
+                dst = dst[4:];
         }
 }
 
 type encoder struct {
         err     os.Error;
         enc     *Encoding;
         w       io.Writer;
         buf     [3]byte;        // buffered data waiting to be encoded
         nbuf    int;            // number of bytes in buf
         out     [1024]byte;     // output buffer
 }
 
 func (e *encoder) Write(p []byte) (n int, err os.Error) {
         if e.err != nil {
                 return 0, e.err
         }
 
         // Leading fringe.
         if e.nbuf > 0 {
                 var i int;
                 for i = 0; i < len(p) && e.nbuf < 3; i++ {
                         e.buf[e.nbuf] = p[i];
                         e.nbuf++;
                 }
                 n += i;
-                p = p[i:len(p)];
+                p = p[i:];
                 if e.nbuf < 3 {
                         return
                 }
                 e.enc.Encode(&e.out, &e.buf);
                 if _, e.err = e.w.Write(e.out[0:4]); e.err != nil {
                         return n, e.err
                 }
                 e.nbuf = 0;
         }
 
         // Large interior chunks.
         for len(p) >= 3 {
                 nn := len(e.out) / 4 * 3;
                 if nn > len(p) {
                         nn = len(p)
                 }
                 nn -= nn % 3;
                 if nn > 0 {
                         e.enc.Encode(&e.out, p[0:nn]);
                         if _, e.err = e.w.Write(e.out[0 : nn/3*4]); e.err != nil {
                                 return n, e.err
                         }
                 }
                 n += nn;
-                p = p[nn:len(p)];
+                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;
 }
@@ skipping 105 matching lines @@
 }
 
 func (d *decoder) Read(p []byte) (n int, err os.Error) {
         if d.err != nil {
                 return 0, d.err
         }
 
         // Use leftover decoded output from last read.
         if len(d.out) > 0 {
                 n = copy(p, d.out);
-                d.out = d.out[n:len(d.out)];
+                d.out = d.out[n:];
                 return n, nil;
         }
 
         // Read a chunk.
         nn := len(p) / 3 * 4;
         if nn < 4 {
                 nn = 4
         }
         if nn > len(d.buf) {
                 nn = len(d.buf)
         }
         nn, d.err = io.ReadAtLeast(d.r, d.buf[d.nbuf:nn], 4-d.nbuf);
         d.nbuf += nn;
         if d.nbuf < 4 {
                 return 0, d.err
         }
 
         // Decode chunk into p, or d.out and then p if p is too small.
         nr := d.nbuf / 4 * 4;
         nw := d.nbuf / 4 * 3;
         if nw > len(p) {
                 nw, d.end, d.err = d.enc.decode(&d.outbuf, d.buf[0:nr]);
                 d.out = d.outbuf[0:nw];
                 n = copy(p, d.out);
-                d.out = d.out[n:len(d.out)];
+                d.out = d.out[n:];
         } else {
                 n, d.end, d.err = d.enc.decode(p, d.buf[0:nr])
         }
         d.nbuf -= nr;
         for i := 0; i < d.nbuf; i++ {
                 d.buf[i] = d.buf[i+nr]
         }
 
         if d.err == nil {
                 d.err = err
         }
         return n, d.err;
 }
 
 // NewDecoder constructs a new base64 stream decoder.
 func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
         return &decoder{enc: enc, r: r}
 }
 
 // DecodeLen returns the maximum length in bytes of the decoded data
 // corresponding to n bytes of base64-encoded data.
 func (enc *Encoding) DecodedLen(n int) int      { return n / 4 * 3 }