io.StringBytes -> strings.Bytes
io.ByteBuffer -> bytes.Buffer
left io.ByteBuffer stub around for now,
for protocol compiler.
R=r
OCL=30861
CL=30872
diff --git a/src/pkg/bytes/buffer.go b/src/pkg/bytes/buffer.go
new file mode 100644
index 0000000..58e06e9
--- /dev/null
+++ b/src/pkg/bytes/buffer.go
@@ -0,0 +1,125 @@
+// 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 bytes
+
+// Simple byte buffer for marshaling data.
+
+import (
+ "bytes";
+ "os";
+)
+
+func bytecopy(dst []byte, doff int, src []byte, soff int, count int) {
+ for ; count > 0; count-- {
+ dst[doff] = src[soff];
+ doff++;
+ soff++;
+ }
+}
+
+// A Buffer is a variable-sized buffer of bytes
+// 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)]
+}
+
+// Data returns the contents of the unread portion of the buffer;
+// len(b.Data()) == b.Len().
+func (b *Buffer) Data() []byte {
+ return b.buf[b.off : len(b.buf)]
+}
+
+// Len returns the number of bytes of the unread portion of the buffer;
+// b.Len() == len(b.Data()).
+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().
+func (b *Buffer) Truncate(n int) {
+ if n == 0 {
+ // Reuse buffer space.
+ b.off = 0;
+ }
+ 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);
+}
+
+// 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();
+ n = len(p);
+
+ if len(b.buf) + n > cap(b.buf) {
+ // not enough space at end
+ buf := b.buf;
+ if m + n > cap(b.buf) {
+ // not enough space anywhere
+ buf = make([]byte, 2*cap(b.buf) + n)
+ }
+ bytecopy(buf, 0, b.buf, b.off, m);
+ b.buf = buf;
+ b.off = 0
+ }
+
+ b.buf = b.buf[0 : b.off + m + n];
+ bytecopy(b.buf, b.off + m, p, 0, n);
+ return n, nil
+}
+
+// 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.Write([]byte{c});
+ return nil;
+}
+
+// Read reads the next len(p) bytes from the buffer or until the buffer
+// is drained. The return value n is the number of bytes read. If the
+// buffer has no data to return, err is os.EOF even if len(p) is zero;
+// otherwise it is nil.
+func (b *Buffer) Read(p []byte) (n int, err os.Error) {
+ if b.off >= len(b.buf) {
+ return 0, os.EOF
+ }
+ m := b.Len();
+ n = len(p);
+
+ if n > m {
+ // more bytes requested than available
+ n = m
+ }
+
+ bytecopy(p, 0, b.buf, b.off, n);
+ b.off += n;
+ return n, err
+}
+
+// ReadByte reads and returns the next byte from the buffer.
+// If no byte is available, it returns error os.EOF.
+func (b *Buffer) ReadByte() (c byte, err os.Error) {
+ if b.off >= len(b.buf) {
+ return 0, os.EOF;
+ }
+ 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, 0};
+}
