src/pkg/bufio/bufio.go - go - Git at Google

 // 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.

 // This package implements buffered I/O.  It wraps an io.Reader or io.Writer
 // object, creating another object (Reader or Writer) that also implements
 // the interface but provides buffering and some help for textual I/O.
 package bufio

 import (
 	"bytes"
 	"io"
 	"os"
 	"strconv"
 	"utf8"
 )


 const (
 	defaultBufSize = 4096
 )

 // Errors introduced by this package.
 type Error struct {
 	os.ErrorString
 }

 var (
 	ErrInvalidUnreadByte os.Error = &Error{"bufio: invalid use of UnreadByte"}
 	ErrInvalidUnreadRune os.Error = &Error{"bufio: invalid use of UnreadRune"}
 	ErrBufferFull        os.Error = &Error{"bufio: buffer full"}
 	ErrNegativeCount     os.Error = &Error{"bufio: negative count"}
 	errInternal          os.Error = &Error{"bufio: internal error"}
 )

 // BufSizeError is the error representing an invalid buffer size.
 type BufSizeError int

 func (b BufSizeError) String() string {
 	return "bufio: bad buffer size " + strconv.Itoa(int(b))
 }


 // Buffered input.

 // Reader implements buffering for an io.Reader object.
 type Reader struct {
 	buf          []byte
 	rd           io.Reader
 	r, w         int
 	err          os.Error
 	lastByte     int
 	lastRuneSize int
 }

 // NewReaderSize creates a new Reader whose buffer has the specified size,
 // which must be greater than zero.  If the argument io.Reader is already a
 // Reader with large enough size, it returns the underlying Reader.
 // It returns the Reader and any error.
 func NewReaderSize(rd io.Reader, size int) (*Reader, os.Error) {
 	if size <= 0 {
 		return nil, BufSizeError(size)
 	}
 	// Is it already a Reader?
 	b, ok := rd.(*Reader)
 	if ok && len(b.buf) >= size {
 		return b, nil
 	}
 	b = new(Reader)
 	b.buf = make([]byte, size)
 	b.rd = rd
 	b.lastByte = -1
 	b.lastRuneSize = -1
 	return b, nil
 }

 // NewReader returns a new Reader whose buffer has the default size.
 func NewReader(rd io.Reader) *Reader {
 	b, err := NewReaderSize(rd, defaultBufSize)
 	if err != nil {
 		// cannot happen - defaultBufSize is a valid size
 		panic(err)
 	}
 	return b
 }

 // fill reads a new chunk into the buffer.
 func (b *Reader) fill() {
 	// Slide existing data to beginning.
 	if b.r > 0 {
 		copy(b.buf, b.buf[b.r:b.w])
 		b.w -= b.r
 		b.r = 0
 	}

 	// Read new data.
 	n, e := b.rd.Read(b.buf[b.w:])
 	b.w += n
 	if e != nil {
 		b.err = e
 	}
 }

 // Peek returns the next n bytes without advancing the reader. The bytes stop
 // being valid at the next read call. If Peek returns fewer than n bytes, it
 // also returns an error explaining why the read is short. The error is
 // ErrBufferFull if n is larger than b's buffer size.
 func (b *Reader) Peek(n int) ([]byte, os.Error) {
 	if n < 0 {
 		return nil, ErrNegativeCount
 	}
 	if n > len(b.buf) {
 		return nil, ErrBufferFull
 	}
 	for b.w-b.r < n && b.err == nil {
 		b.fill()
 	}
 	m := b.w - b.r
 	if m > n {
 		m = n
 	}
 	err := b.err
 	if m < n && err == nil {
 		err = ErrBufferFull
 	}
 	return b.buf[b.r : b.r+m], err
 }

 // Read reads data into p.
 // It returns the number of bytes read into p.
 // It calls Read at most once on the underlying Reader,
 // hence n may be less than len(p).
 // At EOF, the count will be zero and err will be os.EOF.
 func (b *Reader) Read(p []byte) (n int, err os.Error) {
 	n = len(p)
 	if n == 0 {
 		return 0, b.err
 	}
 	if b.w == b.r {
 		if b.err != nil {
 			return 0, b.err
 		}
 		if len(p) >= len(b.buf) {
 			// Large read, empty buffer.
 			// Read directly into p to avoid copy.
 			n, b.err = b.rd.Read(p)
 			if n > 0 {
 				b.lastByte = int(p[n-1])
 				b.lastRuneSize = -1
 			}
 			return n, b.err
 		}
 		b.fill()
 		if b.w == b.r {
 			return 0, b.err
 		}
 	}

 	if n > b.w-b.r {
 		n = b.w - b.r
 	}
 	copy(p[0:n], b.buf[b.r:])
 	b.r += n
 	b.lastByte = int(b.buf[b.r-1])
 	b.lastRuneSize = -1
 	return n, nil
 }

 // ReadByte reads and returns a single byte.
 // If no byte is available, returns an error.
 func (b *Reader) ReadByte() (c byte, err os.Error) {
 	b.lastRuneSize = -1
 	for b.w == b.r {
 		if b.err != nil {
 			return 0, b.err
 		}
 		b.fill()
 	}
 	c = b.buf[b.r]
 	b.r++
 	b.lastByte = int(c)
 	return c, nil
 }

 // UnreadByte unreads the last byte.  Only the most recently read byte can be unread.
 func (b *Reader) UnreadByte() os.Error {
 	b.lastRuneSize = -1
 	if b.r == b.w && b.lastByte >= 0 {
 		b.w = 1
 		b.r = 0
 		b.buf[0] = byte(b.lastByte)
 		b.lastByte = -1
 		return nil
 	}
 	if b.r <= 0 {
 		return ErrInvalidUnreadByte
 	}
 	b.r--
 	b.lastByte = -1
 	return nil
 }

 // ReadRune reads a single UTF-8 encoded Unicode character and returns the
 // rune and its size in bytes.
 func (b *Reader) ReadRune() (rune int, size int, err os.Error) {
 	for b.r+utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r:b.w]) && b.err == nil {
 		b.fill()
 	}
 	b.lastRuneSize = -1
 	if b.r == b.w {
 		return 0, 0, b.err
 	}
 	rune, size = int(b.buf[b.r]), 1
 	if rune >= 0x80 {
 		rune, size = utf8.DecodeRune(b.buf[b.r:b.w])
 	}
 	b.r += size
 	b.lastByte = int(b.buf[b.r-1])
 	b.lastRuneSize = size
 	return rune, size, nil
 }

 // UnreadRune unreads the last rune.  If the most recent read operation on
 // the buffer was not a ReadRune, UnreadRune returns an error.  (In this
 // regard it is stricter than UnreadByte, which will unread the last byte
 // from any read operation.)
 func (b *Reader) UnreadRune() os.Error {
 	if b.lastRuneSize < 0 || b.r == 0 {
 		return ErrInvalidUnreadRune
 	}
 	b.r -= b.lastRuneSize
 	b.lastByte = -1
 	b.lastRuneSize = -1
 	return nil
 }

 // Buffered returns the number of bytes that can be read from the current buffer.
 func (b *Reader) Buffered() int { return b.w - b.r }

 // ReadSlice reads until the first occurrence of delim in the input,
 // returning a slice pointing at the bytes in the buffer.
 // The bytes stop being valid at the next read call.
 // If ReadSlice encounters an error before finding a delimiter,
 // it returns all the data in the buffer and the error itself (often os.EOF).
 // ReadSlice fails with error ErrBufferFull if the buffer fills without a delim.
 // Because the data returned from ReadSlice will be overwritten
 // by the next I/O operation, most clients should use
 // ReadBytes or ReadString instead.
 // ReadSlice returns err != nil if and only if line does not end in delim.
 func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) {
 	// Look in buffer.
 	if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 {
 		line1 := b.buf[b.r : b.r+i+1]
 		b.r += i + 1
 		return line1, nil
 	}

 	// Read more into buffer, until buffer fills or we find delim.
 	for {
 		if b.err != nil {
 			line := b.buf[b.r:b.w]
 			b.r = b.w
 			return line, b.err
 		}

 		n := b.Buffered()
 		b.fill()

 		// Search new part of buffer
 		if i := bytes.IndexByte(b.buf[n:b.w], delim); i >= 0 {
 			line := b.buf[0 : n+i+1]
 			b.r = n + i + 1
 			return line, nil
 		}

 		// Buffer is full?
 		if b.Buffered() >= len(b.buf) {
 			b.r = b.w
 			return b.buf, ErrBufferFull
 		}
 	}
 	panic("not reached")
 }

 // ReadBytes reads until the first occurrence of delim in the input,
 // returning a slice containing the data up to and including the delimiter.
 // If ReadBytes encounters an error before finding a delimiter,
 // it returns the data read before the error and the error itself (often os.EOF).
 // ReadBytes returns err != nil if and only if line does not end in delim.
 func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
 	// Use ReadSlice to look for array,
 	// accumulating full buffers.
 	var frag []byte
 	var full [][]byte
 	err = nil

 	for {
 		var e os.Error
 		frag, e = b.ReadSlice(delim)
 		if e == nil { // got final fragment
 			break
 		}
 		if e != ErrBufferFull { // unexpected error
 			err = e
 			break
 		}

 		// Make a copy of the buffer.
 		buf := make([]byte, len(frag))
 		copy(buf, frag)
 		full = append(full, buf)
 	}

 	// Allocate new buffer to hold the full pieces and the fragment.
 	n := 0
 	for i := range full {
 		n += len(full[i])
 	}
 	n += len(frag)

 	// Copy full pieces and fragment in.
 	buf := make([]byte, n)
 	n = 0
 	for i := range full {
 		n += copy(buf[n:], full[i])
 	}
 	copy(buf[n:], frag)
 	return buf, err
 }

 // ReadString reads until the first occurrence of delim in the input,
 // returning a string containing the data up to and including the delimiter.
 // If ReadString encounters an error before finding a delimiter,
 // it returns the data read before the error and the error itself (often os.EOF).
 // ReadString returns err != nil if and only if line does not end in delim.
 func (b *Reader) ReadString(delim byte) (line string, err os.Error) {
 	bytes, e := b.ReadBytes(delim)
 	return string(bytes), e
 }


 // buffered output

 // Writer implements buffering for an io.Writer object.
 type Writer struct {
 	err os.Error
 	buf []byte
 	n   int
 	wr  io.Writer
 }

 // NewWriterSize creates a new Writer whose buffer has the specified size,
 // which must be greater than zero. If the argument io.Writer is already a
 // Writer with large enough size, it returns the underlying Writer.
 // It returns the Writer and any error.
 func NewWriterSize(wr io.Writer, size int) (*Writer, os.Error) {
 	if size <= 0 {
 		return nil, BufSizeError(size)
 	}
 	// Is it already a Writer?
 	b, ok := wr.(*Writer)
 	if ok && len(b.buf) >= size {
 		return b, nil
 	}
 	b = new(Writer)
 	b.buf = make([]byte, size)
 	b.wr = wr
 	return b, nil
 }

 // NewWriter returns a new Writer whose buffer has the default size.
 func NewWriter(wr io.Writer) *Writer {
 	b, err := NewWriterSize(wr, defaultBufSize)
 	if err != nil {
 		// cannot happen - defaultBufSize is valid size
 		panic(err)
 	}
 	return b
 }

 // Flush writes any buffered data to the underlying io.Writer.
 func (b *Writer) Flush() os.Error {
 	if b.err != nil {
 		return b.err
 	}
 	n, e := b.wr.Write(b.buf[0:b.n])
 	if n < b.n && e == nil {
 		e = io.ErrShortWrite
 	}
 	if e != nil {
 		if n > 0 && n < b.n {
 			copy(b.buf[0:b.n-n], b.buf[n:b.n])
 		}
 		b.n -= n
 		b.err = e
 		return e
 	}
 	b.n = 0
 	return nil
 }

 // Available returns how many bytes are unused in the buffer.
 func (b *Writer) Available() int { return len(b.buf) - b.n }

 // Buffered returns the number of bytes that have been written into the current buffer.
 func (b *Writer) Buffered() int { return b.n }

 // Write writes the contents of p into the buffer.
 // It returns the number of bytes written.
 // If nn < len(p), it also returns an error explaining
 // why the write is short.
 func (b *Writer) Write(p []byte) (nn int, err os.Error) {
 	if b.err != nil {
 		return 0, b.err
 	}
 	nn = 0
 	for len(p) > 0 {
 		n := b.Available()
 		if n <= 0 {
 			if b.Flush(); b.err != nil {
 				break
 			}
 			n = b.Available()
 		}
 		if b.Buffered() == 0 && len(p) >= len(b.buf) {
 			// Large write, empty buffer.
 			// Write directly from p to avoid copy.
 			n, b.err = b.wr.Write(p)
 			nn += n
 			p = p[n:]
 			if b.err != nil {
 				break
 			}
 			continue
 		}
 		if n > len(p) {
 			n = len(p)
 		}
 		copy(b.buf[b.n:b.n+n], p[0:n])
 		b.n += n
 		nn += n
 		p = p[n:]
 	}
 	return nn, b.err
 }

 // WriteByte writes a single byte.
 func (b *Writer) WriteByte(c byte) os.Error {
 	if b.err != nil {
 		return b.err
 	}
 	if b.Available() <= 0 && b.Flush() != nil {
 		return b.err
 	}
 	b.buf[b.n] = c
 	b.n++
 	return nil
 }

 // WriteRune writes a single Unicode code point, returning
 // the number of bytes written and any error.
 func (b *Writer) WriteRune(rune int) (size int, err os.Error) {
 	if rune < utf8.RuneSelf {
 		err = b.WriteByte(byte(rune))
 		if err != nil {
 			return 0, err
 		}
 		return 1, nil
 	}
 	if b.err != nil {
 		return 0, b.err
 	}
 	n := b.Available()
 	if n < utf8.UTFMax {
 		if b.Flush(); b.err != nil {
 			return 0, b.err
 		}
 		n = b.Available()
 		if n < utf8.UTFMax {
 			// Can only happen if buffer is silly small.
 			return b.WriteString(string(rune))
 		}
 	}
 	size = utf8.EncodeRune(b.buf[b.n:], rune)
 	b.n += size
 	return size, nil
 }

 // WriteString writes a string.
 // It returns the number of bytes written.
 // If the count is less than len(s), it also returns an error explaining
 // why the write is short.
 func (b *Writer) WriteString(s string) (int, os.Error) {
 	if b.err != nil {
 		return 0, b.err
 	}
 	// Common case, worth making fast.
 	if b.Available() >= len(s) || len(b.buf) >= len(s) && b.Flush() == nil {
 		for i := 0; i < len(s); i++ { // loop over bytes, not runes.
 			b.buf[b.n] = s[i]
 			b.n++
 		}
 		return len(s), nil
 	}
 	for i := 0; i < len(s); i++ { // loop over bytes, not runes.
 		b.WriteByte(s[i])
 		if b.err != nil {
 			return i, b.err
 		}
 	}
 	return len(s), nil
 }

 // buffered input and output

 // ReadWriter stores pointers to a Reader and a Writer.
 // It implements io.ReadWriter.
 type ReadWriter struct {
 	*Reader
 	*Writer
 }

 // NewReadWriter allocates a new ReadWriter that dispatches to r and w.
 func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
 	return &ReadWriter{r, w}
 }
	// 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.

	// This package implements buffered I/O. It wraps an io.Reader or io.Writer
	// object, creating another object (Reader or Writer) that also implements
	// the interface but provides buffering and some help for textual I/O.
	package bufio

	import (
	"bytes"
	"io"
	"os"
	"strconv"
	"utf8"
	)


	const (
	defaultBufSize = 4096
	)

	// Errors introduced by this package.
	type Error struct {
	os.ErrorString
	}

	var (
	ErrInvalidUnreadByte os.Error = &Error{"bufio: invalid use of UnreadByte"}
	ErrInvalidUnreadRune os.Error = &Error{"bufio: invalid use of UnreadRune"}
	ErrBufferFull os.Error = &Error{"bufio: buffer full"}
	ErrNegativeCount os.Error = &Error{"bufio: negative count"}
	errInternal os.Error = &Error{"bufio: internal error"}
	)

	// BufSizeError is the error representing an invalid buffer size.
	type BufSizeError int

	func (b BufSizeError) String() string {
	return "bufio: bad buffer size " + strconv.Itoa(int(b))
	}


	// Buffered input.

	// Reader implements buffering for an io.Reader object.
	type Reader struct {
	buf []byte
	rd io.Reader
	r, w int
	err os.Error
	lastByte int
	lastRuneSize int
	}

	// NewReaderSize creates a new Reader whose buffer has the specified size,
	// which must be greater than zero. If the argument io.Reader is already a
	// Reader with large enough size, it returns the underlying Reader.
	// It returns the Reader and any error.
	func NewReaderSize(rd io.Reader, size int) (*Reader, os.Error) {
	if size <= 0 {
	return nil, BufSizeError(size)
	}
	// Is it already a Reader?
	b, ok := rd.(*Reader)
	if ok && len(b.buf) >= size {
	return b, nil
	}
	b = new(Reader)
	b.buf = make([]byte, size)
	b.rd = rd
	b.lastByte = -1
	b.lastRuneSize = -1
	return b, nil
	}

	// NewReader returns a new Reader whose buffer has the default size.
	func NewReader(rd io.Reader) *Reader {
	b, err := NewReaderSize(rd, defaultBufSize)
	if err != nil {
	// cannot happen - defaultBufSize is a valid size
	panic(err)
	}
	return b
	}

	// fill reads a new chunk into the buffer.
	func (b *Reader) fill() {
	// Slide existing data to beginning.
	if b.r > 0 {
	copy(b.buf, b.buf[b.r:b.w])
	b.w -= b.r
	b.r = 0
	}

	// Read new data.
	n, e := b.rd.Read(b.buf[b.w:])
	b.w += n
	if e != nil {
	b.err = e
	}
	}

	// Peek returns the next n bytes without advancing the reader. The bytes stop
	// being valid at the next read call. If Peek returns fewer than n bytes, it
	// also returns an error explaining why the read is short. The error is
	// ErrBufferFull if n is larger than b's buffer size.
	func (b *Reader) Peek(n int) ([]byte, os.Error) {
	if n < 0 {
	return nil, ErrNegativeCount
	}
	if n > len(b.buf) {
	return nil, ErrBufferFull
	}
	for b.w-b.r < n && b.err == nil {
	b.fill()
	}
	m := b.w - b.r
	if m > n {
	m = n
	}
	err := b.err
	if m < n && err == nil {
	err = ErrBufferFull
	}
	return b.buf[b.r : b.r+m], err
	}

	// Read reads data into p.
	// It returns the number of bytes read into p.
	// It calls Read at most once on the underlying Reader,
	// hence n may be less than len(p).
	// At EOF, the count will be zero and err will be os.EOF.
	func (b *Reader) Read(p []byte) (n int, err os.Error) {
	n = len(p)
	if n == 0 {
	return 0, b.err
	}
	if b.w == b.r {
	if b.err != nil {
	return 0, b.err
	}
	if len(p) >= len(b.buf) {
	// Large read, empty buffer.
	// Read directly into p to avoid copy.
	n, b.err = b.rd.Read(p)
	if n > 0 {
	b.lastByte = int(p[n-1])
	b.lastRuneSize = -1
	}
	return n, b.err
	}
	b.fill()
	if b.w == b.r {
	return 0, b.err
	}
	}

	if n > b.w-b.r {
	n = b.w - b.r
	}
	copy(p[0:n], b.buf[b.r:])
	b.r += n
	b.lastByte = int(b.buf[b.r-1])
	b.lastRuneSize = -1
	return n, nil
	}

	// ReadByte reads and returns a single byte.
	// If no byte is available, returns an error.
	func (b *Reader) ReadByte() (c byte, err os.Error) {
	b.lastRuneSize = -1
	for b.w == b.r {
	if b.err != nil {
	return 0, b.err
	}
	b.fill()
	}
	c = b.buf[b.r]
	b.r++
	b.lastByte = int(c)
	return c, nil
	}

	// UnreadByte unreads the last byte. Only the most recently read byte can be unread.
	func (b *Reader) UnreadByte() os.Error {
	b.lastRuneSize = -1
	if b.r == b.w && b.lastByte >= 0 {
	b.w = 1
	b.r = 0
	b.buf[0] = byte(b.lastByte)
	b.lastByte = -1
	return nil
	}
	if b.r <= 0 {
	return ErrInvalidUnreadByte
	}
	b.r--
	b.lastByte = -1
	return nil
	}

	// ReadRune reads a single UTF-8 encoded Unicode character and returns the
	// rune and its size in bytes.
	func (b *Reader) ReadRune() (rune int, size int, err os.Error) {
	for b.r+utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r:b.w]) && b.err == nil {
	b.fill()
	}
	b.lastRuneSize = -1
	if b.r == b.w {
	return 0, 0, b.err
	}
	rune, size = int(b.buf[b.r]), 1
	if rune >= 0x80 {
	rune, size = utf8.DecodeRune(b.buf[b.r:b.w])
	}
	b.r += size
	b.lastByte = int(b.buf[b.r-1])
	b.lastRuneSize = size
	return rune, size, nil
	}

	// UnreadRune unreads the last rune. If the most recent read operation on
	// the buffer was not a ReadRune, UnreadRune returns an error. (In this
	// regard it is stricter than UnreadByte, which will unread the last byte
	// from any read operation.)
	func (b *Reader) UnreadRune() os.Error {
	if b.lastRuneSize < 0 \|\| b.r == 0 {
	return ErrInvalidUnreadRune
	}
	b.r -= b.lastRuneSize
	b.lastByte = -1
	b.lastRuneSize = -1
	return nil
	}

	// Buffered returns the number of bytes that can be read from the current buffer.
	func (b *Reader) Buffered() int { return b.w - b.r }

	// ReadSlice reads until the first occurrence of delim in the input,
	// returning a slice pointing at the bytes in the buffer.
	// The bytes stop being valid at the next read call.
	// If ReadSlice encounters an error before finding a delimiter,
	// it returns all the data in the buffer and the error itself (often os.EOF).
	// ReadSlice fails with error ErrBufferFull if the buffer fills without a delim.
	// Because the data returned from ReadSlice will be overwritten
	// by the next I/O operation, most clients should use
	// ReadBytes or ReadString instead.
	// ReadSlice returns err != nil if and only if line does not end in delim.
	func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) {
	// Look in buffer.
	if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 {
	line1 := b.buf[b.r : b.r+i+1]
	b.r += i + 1
	return line1, nil
	}

	// Read more into buffer, until buffer fills or we find delim.
	for {
	if b.err != nil {
	line := b.buf[b.r:b.w]
	b.r = b.w
	return line, b.err
	}

	n := b.Buffered()
	b.fill()

	// Search new part of buffer
	if i := bytes.IndexByte(b.buf[n:b.w], delim); i >= 0 {
	line := b.buf[0 : n+i+1]
	b.r = n + i + 1
	return line, nil
	}

	// Buffer is full?
	if b.Buffered() >= len(b.buf) {
	b.r = b.w
	return b.buf, ErrBufferFull
	}
	}
	panic("not reached")
	}

	// ReadBytes reads until the first occurrence of delim in the input,
	// returning a slice containing the data up to and including the delimiter.
	// If ReadBytes encounters an error before finding a delimiter,
	// it returns the data read before the error and the error itself (often os.EOF).
	// ReadBytes returns err != nil if and only if line does not end in delim.
	func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
	// Use ReadSlice to look for array,
	// accumulating full buffers.
	var frag []byte
	var full [][]byte
	err = nil

	for {
	var e os.Error
	frag, e = b.ReadSlice(delim)
	if e == nil { // got final fragment
	break
	}
	if e != ErrBufferFull { // unexpected error
	err = e
	break
	}

	// Make a copy of the buffer.
	buf := make([]byte, len(frag))
	copy(buf, frag)
	full = append(full, buf)
	}

	// Allocate new buffer to hold the full pieces and the fragment.
	n := 0
	for i := range full {
	n += len(full[i])
	}
	n += len(frag)

	// Copy full pieces and fragment in.
	buf := make([]byte, n)
	n = 0
	for i := range full {
	n += copy(buf[n:], full[i])
	}
	copy(buf[n:], frag)
	return buf, err
	}

	// ReadString reads until the first occurrence of delim in the input,
	// returning a string containing the data up to and including the delimiter.
	// If ReadString encounters an error before finding a delimiter,
	// it returns the data read before the error and the error itself (often os.EOF).
	// ReadString returns err != nil if and only if line does not end in delim.
	func (b *Reader) ReadString(delim byte) (line string, err os.Error) {
	bytes, e := b.ReadBytes(delim)
	return string(bytes), e
	}


	// buffered output

	// Writer implements buffering for an io.Writer object.
	type Writer struct {
	err os.Error
	buf []byte
	n int
	wr io.Writer
	}

	// NewWriterSize creates a new Writer whose buffer has the specified size,
	// which must be greater than zero. If the argument io.Writer is already a
	// Writer with large enough size, it returns the underlying Writer.
	// It returns the Writer and any error.
	func NewWriterSize(wr io.Writer, size int) (*Writer, os.Error) {
	if size <= 0 {
	return nil, BufSizeError(size)
	}
	// Is it already a Writer?
	b, ok := wr.(*Writer)
	if ok && len(b.buf) >= size {
	return b, nil
	}
	b = new(Writer)
	b.buf = make([]byte, size)
	b.wr = wr
	return b, nil
	}

	// NewWriter returns a new Writer whose buffer has the default size.
	func NewWriter(wr io.Writer) *Writer {
	b, err := NewWriterSize(wr, defaultBufSize)
	if err != nil {
	// cannot happen - defaultBufSize is valid size
	panic(err)
	}
	return b
	}

	// Flush writes any buffered data to the underlying io.Writer.
	func (b *Writer) Flush() os.Error {
	if b.err != nil {
	return b.err
	}
	n, e := b.wr.Write(b.buf[0:b.n])
	if n < b.n && e == nil {
	e = io.ErrShortWrite
	}
	if e != nil {
	if n > 0 && n < b.n {
	copy(b.buf[0:b.n-n], b.buf[n:b.n])
	}
	b.n -= n
	b.err = e
	return e
	}
	b.n = 0
	return nil
	}

	// Available returns how many bytes are unused in the buffer.
	func (b *Writer) Available() int { return len(b.buf) - b.n }

	// Buffered returns the number of bytes that have been written into the current buffer.
	func (b *Writer) Buffered() int { return b.n }

	// Write writes the contents of p into the buffer.
	// It returns the number of bytes written.
	// If nn < len(p), it also returns an error explaining
	// why the write is short.
	func (b *Writer) Write(p []byte) (nn int, err os.Error) {
	if b.err != nil {
	return 0, b.err
	}
	nn = 0
	for len(p) > 0 {
	n := b.Available()
	if n <= 0 {
	if b.Flush(); b.err != nil {
	break
	}
	n = b.Available()
	}
	if b.Buffered() == 0 && len(p) >= len(b.buf) {
	// Large write, empty buffer.
	// Write directly from p to avoid copy.
	n, b.err = b.wr.Write(p)
	nn += n
	p = p[n:]
	if b.err != nil {
	break
	}
	continue
	}
	if n > len(p) {
	n = len(p)
	}
	copy(b.buf[b.n:b.n+n], p[0:n])
	b.n += n
	nn += n
	p = p[n:]
	}
	return nn, b.err
	}

	// WriteByte writes a single byte.
	func (b *Writer) WriteByte(c byte) os.Error {
	if b.err != nil {
	return b.err
	}
	if b.Available() <= 0 && b.Flush() != nil {
	return b.err
	}
	b.buf[b.n] = c
	b.n++
	return nil
	}

	// WriteRune writes a single Unicode code point, returning
	// the number of bytes written and any error.
	func (b *Writer) WriteRune(rune int) (size int, err os.Error) {
	if rune < utf8.RuneSelf {
	err = b.WriteByte(byte(rune))
	if err != nil {
	return 0, err
	}
	return 1, nil
	}
	if b.err != nil {
	return 0, b.err
	}
	n := b.Available()
	if n < utf8.UTFMax {
	if b.Flush(); b.err != nil {
	return 0, b.err
	}
	n = b.Available()
	if n < utf8.UTFMax {
	// Can only happen if buffer is silly small.
	return b.WriteString(string(rune))
	}
	}
	size = utf8.EncodeRune(b.buf[b.n:], rune)
	b.n += size
	return size, nil
	}

	// WriteString writes a string.
	// It returns the number of bytes written.
	// If the count is less than len(s), it also returns an error explaining
	// why the write is short.
	func (b *Writer) WriteString(s string) (int, os.Error) {
	if b.err != nil {
	return 0, b.err
	}
	// Common case, worth making fast.
	if b.Available() >= len(s) \|\| len(b.buf) >= len(s) && b.Flush() == nil {
	for i := 0; i < len(s); i++ { // loop over bytes, not runes.
	b.buf[b.n] = s[i]
	b.n++
	}
	return len(s), nil
	}
	for i := 0; i < len(s); i++ { // loop over bytes, not runes.
	b.WriteByte(s[i])
	if b.err != nil {
	return i, b.err
	}
	}
	return len(s), nil
	}

	// buffered input and output

	// ReadWriter stores pointers to a Reader and a Writer.
	// It implements io.ReadWriter.
	type ReadWriter struct {
	*Reader
	*Writer
	}

	// NewReadWriter allocates a new ReadWriter that dispatches to r and w.
	func NewReadWriter(r Reader, w Writer) *ReadWriter {
	return &ReadWriter{r, w}
	}