1) Change default gofmt default settings for
parsing and printing to new syntax.
Use -oldparser to parse the old syntax,
use -oldprinter to print the old syntax.
2) Change default gofmt formatting settings
to use tabs for indentation only and to use
spaces for alignment. This will make the code
alignment insensitive to an editor's tabwidth.
Use -spaces=false to use tabs for alignment.
3) Manually changed src/exp/parser/parser_test.go
so that it doesn't try to parse the parser's
source files using the old syntax (they have
new syntax now).
4) gofmt -w src misc test/bench
1st set of files.
R=rsc
CC=agl, golang-dev, iant, ken2, r
https://golang.org/cl/180047
diff --git a/src/pkg/bytes/buffer.go b/src/pkg/bytes/buffer.go
index b302b65..bbca70b 100644
--- a/src/pkg/bytes/buffer.go
+++ b/src/pkg/bytes/buffer.go
@@ -7,15 +7,15 @@
// Simple byte buffer for marshaling data.
import (
- "io";
- "os";
+ "io"
+ "os"
)
// Copy from string to byte array at offset doff. Assume there's room.
func copyString(dst []byte, doff int, str string) {
for soff := 0; soff < len(str); soff++ {
- dst[doff] = str[soff];
- doff++;
+ dst[doff] = str[soff]
+ doff++
}
}
@@ -23,15 +23,15 @@
// with Read and Write methods.
// The zero value for Buffer is an empty buffer ready to use.
type Buffer struct {
- buf []byte; // contents are the bytes buf[off : len(buf)]
- off int; // read at &buf[off], write at &buf[len(buf)]
- oneByte [1]byte; // avoid allocation of slice on each WriteByte
- bootstrap [64]byte; // memory to hold first slice; helps small buffers (Printf) avoid allocation.
+ buf []byte // contents are the bytes buf[off : len(buf)]
+ off int // read at &buf[off], write at &buf[len(buf)]
+ oneByte [1]byte // avoid allocation of slice on each WriteByte
+ bootstrap [64]byte // memory to hold first slice; helps small buffers (Printf) avoid allocation.
}
// Bytes returns the contents of the unread portion of the buffer;
// len(b.Bytes()) == b.Len().
-func (b *Buffer) Bytes() []byte { return b.buf[b.off:] }
+func (b *Buffer) Bytes() []byte { return b.buf[b.off:] }
// String returns the contents of the unread portion of the buffer
// as a string. If the Buffer is a nil pointer, it returns "<nil>".
@@ -40,12 +40,12 @@
// Special case, useful in debugging.
return "<nil>"
}
- return string(b.buf[b.off:]);
+ return string(b.buf[b.off:])
}
// Len returns the number of bytes of the unread portion of the buffer;
// b.Len() == len(b.Bytes()).
-func (b *Buffer) Len() int { return len(b.buf) - b.off }
+func (b *Buffer) Len() int { return len(b.buf) - b.off }
// Truncate discards all but the first n unread bytes from the buffer.
// It is an error to call b.Truncate(n) with n > b.Len().
@@ -54,64 +54,64 @@
// Reuse buffer space.
b.off = 0
}
- b.buf = b.buf[0 : b.off+n];
+ b.buf = b.buf[0 : b.off+n]
}
// Reset resets the buffer so it has no content.
// b.Reset() is the same as b.Truncate(0).
-func (b *Buffer) Reset() { b.Truncate(0) }
+func (b *Buffer) Reset() { b.Truncate(0) }
// Resize buffer to guarantee enough space for n more bytes.
// After this call, the state of b.buf is inconsistent.
// It must be fixed up as is done in Write and WriteString.
func (b *Buffer) resize(n int) {
- var buf []byte;
+ var buf []byte
if b.buf == nil && n <= len(b.bootstrap) {
buf = &b.bootstrap
} else {
- buf = b.buf;
+ buf = b.buf
if len(b.buf)+n > cap(b.buf) {
// not enough space anywhere
buf = make([]byte, 2*cap(b.buf)+n)
}
- copy(buf, b.buf[b.off:]);
+ copy(buf, b.buf[b.off:])
}
- b.buf = buf;
- b.off = 0;
+ b.buf = buf
+ b.off = 0
}
// Write appends the contents of p to the buffer. The return
// value n is the length of p; err is always nil.
func (b *Buffer) Write(p []byte) (n int, err os.Error) {
- m := b.Len();
+ m := b.Len()
// If buffer is empty, reset to recover space.
if m == 0 && b.off != 0 {
b.Truncate(0)
}
- n = len(p);
+ n = len(p)
if len(b.buf)+n > cap(b.buf) {
b.resize(n)
}
- b.buf = b.buf[0 : b.off+m+n];
- copy(b.buf[b.off+m:], p);
- return n, nil;
+ b.buf = b.buf[0 : b.off+m+n]
+ copy(b.buf[b.off+m:], p)
+ return n, nil
}
// WriteString appends the contents of s to the buffer. The return
// value n is the length of s; err is always nil.
func (b *Buffer) WriteString(s string) (n int, err os.Error) {
- m := b.Len();
+ m := b.Len()
// If buffer is empty, reset to recover space.
if m == 0 && b.off != 0 {
b.Truncate(0)
}
- n = len(s);
+ n = len(s)
if len(b.buf)+n > cap(b.buf) {
b.resize(n)
}
- b.buf = b.buf[0 : b.off+m+n];
- copyString(b.buf, b.off+m, s);
- return n, nil;
+ b.buf = b.buf[0 : b.off+m+n]
+ copyString(b.buf, b.off+m, s)
+ return n, nil
}
// MinRead is the minimum slice size passed to a Read call by
@@ -131,7 +131,7 @@
}
for {
if cap(b.buf)-len(b.buf) < MinRead {
- var newBuf []byte;
+ var newBuf []byte
// can we get space without allocation?
if b.off+cap(b.buf)-len(b.buf) >= MinRead {
// reuse beginning of buffer
@@ -140,13 +140,13 @@
// not enough space at end; put space on end
newBuf = make([]byte, len(b.buf)-b.off, 2*(cap(b.buf)-b.off)+MinRead)
}
- copy(newBuf, b.buf[b.off:]);
- b.buf = newBuf;
- b.off = 0;
+ copy(newBuf, b.buf[b.off:])
+ b.buf = newBuf
+ b.off = 0
}
- m, e := r.Read(b.buf[len(b.buf):cap(b.buf)]);
- b.buf = b.buf[b.off : len(b.buf)+m];
- n += int64(m);
+ m, e := r.Read(b.buf[len(b.buf):cap(b.buf)])
+ b.buf = b.buf[b.off : len(b.buf)+m]
+ n += int64(m)
if e == os.EOF {
break
}
@@ -154,7 +154,7 @@
return n, e
}
}
- return n, nil; // err is EOF, so return nil explicitly
+ return n, nil // err is EOF, so return nil explicitly
}
// WriteTo writes data to w until the buffer is drained or an error
@@ -162,25 +162,25 @@
// Any error encountered during the write is also returned.
func (b *Buffer) WriteTo(w io.Writer) (n int64, err os.Error) {
for b.off < len(b.buf) {
- m, e := w.Write(b.buf[b.off:]);
- n += int64(m);
- b.off += m;
+ m, e := w.Write(b.buf[b.off:])
+ n += int64(m)
+ b.off += m
if e != nil {
return n, e
}
}
// Buffer is now empty; reset.
- b.Truncate(0);
- return;
+ b.Truncate(0)
+ return
}
// WriteByte appends the byte c to the buffer.
// The returned error is always nil, but is included
// to match bufio.Writer's WriteByte.
func (b *Buffer) WriteByte(c byte) os.Error {
- b.oneByte[0] = c;
- b.Write(&b.oneByte);
- return nil;
+ b.oneByte[0] = c
+ b.Write(&b.oneByte)
+ return nil
}
// Read reads the next len(p) bytes from the buffer or until the buffer
@@ -190,20 +190,20 @@
func (b *Buffer) Read(p []byte) (n int, err os.Error) {
if b.off >= len(b.buf) {
// Buffer is empty, reset to recover space.
- b.Truncate(0);
- return 0, os.EOF;
+ b.Truncate(0)
+ return 0, os.EOF
}
- m := b.Len();
- n = len(p);
+ m := b.Len()
+ n = len(p)
if n > m {
// more bytes requested than available
n = m
}
- copy(p, b.buf[b.off:b.off+n]);
- b.off += n;
- return n, err;
+ copy(p, b.buf[b.off:b.off+n])
+ b.off += n
+ return n, err
}
// ReadByte reads and returns the next byte from the buffer.
@@ -211,22 +211,22 @@
func (b *Buffer) ReadByte() (c byte, err os.Error) {
if b.off >= len(b.buf) {
// Buffer is empty, reset to recover space.
- b.Truncate(0);
- return 0, os.EOF;
+ b.Truncate(0)
+ return 0, os.EOF
}
- c = b.buf[b.off];
- b.off++;
- return c, nil;
+ c = b.buf[b.off]
+ b.off++
+ return c, nil
}
// NewBuffer creates and initializes a new Buffer
// using buf as its initial contents.
-func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} }
+func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} }
// NewBufferString creates and initializes a new Buffer
// using string s as its initial contents.
func NewBufferString(s string) *Buffer {
- buf := make([]byte, len(s));
- copyString(buf, 0, s);
- return &Buffer{buf: buf};
+ buf := make([]byte, len(s))
+ copyString(buf, 0, s)
+ return &Buffer{buf: buf}
}
