Source file src/bufio/bufio.go

     1	// Copyright 2009 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// Package bufio implements buffered I/O. It wraps an io.Reader or io.Writer
     6	// object, creating another object (Reader or Writer) that also implements
     7	// the interface but provides buffering and some help for textual I/O.
     8	package bufio
     9	
    10	import (
    11		"bytes"
    12		"errors"
    13		"io"
    14		"unicode/utf8"
    15	)
    16	
    17	const (
    18		defaultBufSize = 4096
    19	)
    20	
    21	var (
    22		ErrInvalidUnreadByte = errors.New("bufio: invalid use of UnreadByte")
    23		ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune")
    24		ErrBufferFull        = errors.New("bufio: buffer full")
    25		ErrNegativeCount     = errors.New("bufio: negative count")
    26	)
    27	
    28	// Buffered input.
    29	
    30	// Reader implements buffering for an io.Reader object.
    31	type Reader struct {
    32		buf          []byte
    33		rd           io.Reader // reader provided by the client
    34		r, w         int       // buf read and write positions
    35		err          error
    36		lastByte     int // last byte read for UnreadByte; -1 means invalid
    37		lastRuneSize int // size of last rune read for UnreadRune; -1 means invalid
    38	}
    39	
    40	const minReadBufferSize = 16
    41	const maxConsecutiveEmptyReads = 100
    42	
    43	// NewReaderSize returns a new Reader whose buffer has at least the specified
    44	// size. If the argument io.Reader is already a Reader with large enough
    45	// size, it returns the underlying Reader.
    46	func NewReaderSize(rd io.Reader, size int) *Reader {
    47		// Is it already a Reader?
    48		b, ok := rd.(*Reader)
    49		if ok && len(b.buf) >= size {
    50			return b
    51		}
    52		if size < minReadBufferSize {
    53			size = minReadBufferSize
    54		}
    55		r := new(Reader)
    56		r.reset(make([]byte, size), rd)
    57		return r
    58	}
    59	
    60	// NewReader returns a new Reader whose buffer has the default size.
    61	func NewReader(rd io.Reader) *Reader {
    62		return NewReaderSize(rd, defaultBufSize)
    63	}
    64	
    65	// Size returns the size of the underlying buffer in bytes.
    66	func (b *Reader) Size() int { return len(b.buf) }
    67	
    68	// Reset discards any buffered data, resets all state, and switches
    69	// the buffered reader to read from r.
    70	func (b *Reader) Reset(r io.Reader) {
    71		b.reset(b.buf, r)
    72	}
    73	
    74	func (b *Reader) reset(buf []byte, r io.Reader) {
    75		*b = Reader{
    76			buf:          buf,
    77			rd:           r,
    78			lastByte:     -1,
    79			lastRuneSize: -1,
    80		}
    81	}
    82	
    83	var errNegativeRead = errors.New("bufio: reader returned negative count from Read")
    84	
    85	// fill reads a new chunk into the buffer.
    86	func (b *Reader) fill() {
    87		// Slide existing data to beginning.
    88		if b.r > 0 {
    89			copy(b.buf, b.buf[b.r:b.w])
    90			b.w -= b.r
    91			b.r = 0
    92		}
    93	
    94		if b.w >= len(b.buf) {
    95			panic("bufio: tried to fill full buffer")
    96		}
    97	
    98		// Read new data: try a limited number of times.
    99		for i := maxConsecutiveEmptyReads; i > 0; i-- {
   100			n, err := b.rd.Read(b.buf[b.w:])
   101			if n < 0 {
   102				panic(errNegativeRead)
   103			}
   104			b.w += n
   105			if err != nil {
   106				b.err = err
   107				return
   108			}
   109			if n > 0 {
   110				return
   111			}
   112		}
   113		b.err = io.ErrNoProgress
   114	}
   115	
   116	func (b *Reader) readErr() error {
   117		err := b.err
   118		b.err = nil
   119		return err
   120	}
   121	
   122	// Peek returns the next n bytes without advancing the reader. The bytes stop
   123	// being valid at the next read call. If Peek returns fewer than n bytes, it
   124	// also returns an error explaining why the read is short. The error is
   125	// ErrBufferFull if n is larger than b's buffer size.
   126	//
   127	// Calling Peek prevents a UnreadByte or UnreadRune call from succeeding
   128	// until the next read operation.
   129	func (b *Reader) Peek(n int) ([]byte, error) {
   130		if n < 0 {
   131			return nil, ErrNegativeCount
   132		}
   133	
   134		b.lastByte = -1
   135		b.lastRuneSize = -1
   136	
   137		for b.w-b.r < n && b.w-b.r < len(b.buf) && b.err == nil {
   138			b.fill() // b.w-b.r < len(b.buf) => buffer is not full
   139		}
   140	
   141		if n > len(b.buf) {
   142			return b.buf[b.r:b.w], ErrBufferFull
   143		}
   144	
   145		// 0 <= n <= len(b.buf)
   146		var err error
   147		if avail := b.w - b.r; avail < n {
   148			// not enough data in buffer
   149			n = avail
   150			err = b.readErr()
   151			if err == nil {
   152				err = ErrBufferFull
   153			}
   154		}
   155		return b.buf[b.r : b.r+n], err
   156	}
   157	
   158	// Discard skips the next n bytes, returning the number of bytes discarded.
   159	//
   160	// If Discard skips fewer than n bytes, it also returns an error.
   161	// If 0 <= n <= b.Buffered(), Discard is guaranteed to succeed without
   162	// reading from the underlying io.Reader.
   163	func (b *Reader) Discard(n int) (discarded int, err error) {
   164		if n < 0 {
   165			return 0, ErrNegativeCount
   166		}
   167		if n == 0 {
   168			return
   169		}
   170		remain := n
   171		for {
   172			skip := b.Buffered()
   173			if skip == 0 {
   174				b.fill()
   175				skip = b.Buffered()
   176			}
   177			if skip > remain {
   178				skip = remain
   179			}
   180			b.r += skip
   181			remain -= skip
   182			if remain == 0 {
   183				return n, nil
   184			}
   185			if b.err != nil {
   186				return n - remain, b.readErr()
   187			}
   188		}
   189	}
   190	
   191	// Read reads data into p.
   192	// It returns the number of bytes read into p.
   193	// The bytes are taken from at most one Read on the underlying Reader,
   194	// hence n may be less than len(p).
   195	// To read exactly len(p) bytes, use io.ReadFull(b, p).
   196	// At EOF, the count will be zero and err will be io.EOF.
   197	func (b *Reader) Read(p []byte) (n int, err error) {
   198		n = len(p)
   199		if n == 0 {
   200			if b.Buffered() > 0 {
   201				return 0, nil
   202			}
   203			return 0, b.readErr()
   204		}
   205		if b.r == b.w {
   206			if b.err != nil {
   207				return 0, b.readErr()
   208			}
   209			if len(p) >= len(b.buf) {
   210				// Large read, empty buffer.
   211				// Read directly into p to avoid copy.
   212				n, b.err = b.rd.Read(p)
   213				if n < 0 {
   214					panic(errNegativeRead)
   215				}
   216				if n > 0 {
   217					b.lastByte = int(p[n-1])
   218					b.lastRuneSize = -1
   219				}
   220				return n, b.readErr()
   221			}
   222			// One read.
   223			// Do not use b.fill, which will loop.
   224			b.r = 0
   225			b.w = 0
   226			n, b.err = b.rd.Read(b.buf)
   227			if n < 0 {
   228				panic(errNegativeRead)
   229			}
   230			if n == 0 {
   231				return 0, b.readErr()
   232			}
   233			b.w += n
   234		}
   235	
   236		// copy as much as we can
   237		n = copy(p, b.buf[b.r:b.w])
   238		b.r += n
   239		b.lastByte = int(b.buf[b.r-1])
   240		b.lastRuneSize = -1
   241		return n, nil
   242	}
   243	
   244	// ReadByte reads and returns a single byte.
   245	// If no byte is available, returns an error.
   246	func (b *Reader) ReadByte() (byte, error) {
   247		b.lastRuneSize = -1
   248		for b.r == b.w {
   249			if b.err != nil {
   250				return 0, b.readErr()
   251			}
   252			b.fill() // buffer is empty
   253		}
   254		c := b.buf[b.r]
   255		b.r++
   256		b.lastByte = int(c)
   257		return c, nil
   258	}
   259	
   260	// UnreadByte unreads the last byte. Only the most recently read byte can be unread.
   261	//
   262	// UnreadByte returns an error if the most recent method called on the
   263	// Reader was not a read operation. Notably, Peek is not considered a
   264	// read operation.
   265	func (b *Reader) UnreadByte() error {
   266		if b.lastByte < 0 || b.r == 0 && b.w > 0 {
   267			return ErrInvalidUnreadByte
   268		}
   269		// b.r > 0 || b.w == 0
   270		if b.r > 0 {
   271			b.r--
   272		} else {
   273			// b.r == 0 && b.w == 0
   274			b.w = 1
   275		}
   276		b.buf[b.r] = byte(b.lastByte)
   277		b.lastByte = -1
   278		b.lastRuneSize = -1
   279		return nil
   280	}
   281	
   282	// ReadRune reads a single UTF-8 encoded Unicode character and returns the
   283	// rune and its size in bytes. If the encoded rune is invalid, it consumes one byte
   284	// and returns unicode.ReplacementChar (U+FFFD) with a size of 1.
   285	func (b *Reader) ReadRune() (r rune, size int, err error) {
   286		for b.r+utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r:b.w]) && b.err == nil && b.w-b.r < len(b.buf) {
   287			b.fill() // b.w-b.r < len(buf) => buffer is not full
   288		}
   289		b.lastRuneSize = -1
   290		if b.r == b.w {
   291			return 0, 0, b.readErr()
   292		}
   293		r, size = rune(b.buf[b.r]), 1
   294		if r >= utf8.RuneSelf {
   295			r, size = utf8.DecodeRune(b.buf[b.r:b.w])
   296		}
   297		b.r += size
   298		b.lastByte = int(b.buf[b.r-1])
   299		b.lastRuneSize = size
   300		return r, size, nil
   301	}
   302	
   303	// UnreadRune unreads the last rune. If the most recent method called on
   304	// the Reader was not a ReadRune, UnreadRune returns an error. (In this
   305	// regard it is stricter than UnreadByte, which will unread the last byte
   306	// from any read operation.)
   307	func (b *Reader) UnreadRune() error {
   308		if b.lastRuneSize < 0 || b.r < b.lastRuneSize {
   309			return ErrInvalidUnreadRune
   310		}
   311		b.r -= b.lastRuneSize
   312		b.lastByte = -1
   313		b.lastRuneSize = -1
   314		return nil
   315	}
   316	
   317	// Buffered returns the number of bytes that can be read from the current buffer.
   318	func (b *Reader) Buffered() int { return b.w - b.r }
   319	
   320	// ReadSlice reads until the first occurrence of delim in the input,
   321	// returning a slice pointing at the bytes in the buffer.
   322	// The bytes stop being valid at the next read.
   323	// If ReadSlice encounters an error before finding a delimiter,
   324	// it returns all the data in the buffer and the error itself (often io.EOF).
   325	// ReadSlice fails with error ErrBufferFull if the buffer fills without a delim.
   326	// Because the data returned from ReadSlice will be overwritten
   327	// by the next I/O operation, most clients should use
   328	// ReadBytes or ReadString instead.
   329	// ReadSlice returns err != nil if and only if line does not end in delim.
   330	func (b *Reader) ReadSlice(delim byte) (line []byte, err error) {
   331		s := 0 // search start index
   332		for {
   333			// Search buffer.
   334			if i := bytes.IndexByte(b.buf[b.r+s:b.w], delim); i >= 0 {
   335				i += s
   336				line = b.buf[b.r : b.r+i+1]
   337				b.r += i + 1
   338				break
   339			}
   340	
   341			// Pending error?
   342			if b.err != nil {
   343				line = b.buf[b.r:b.w]
   344				b.r = b.w
   345				err = b.readErr()
   346				break
   347			}
   348	
   349			// Buffer full?
   350			if b.Buffered() >= len(b.buf) {
   351				b.r = b.w
   352				line = b.buf
   353				err = ErrBufferFull
   354				break
   355			}
   356	
   357			s = b.w - b.r // do not rescan area we scanned before
   358	
   359			b.fill() // buffer is not full
   360		}
   361	
   362		// Handle last byte, if any.
   363		if i := len(line) - 1; i >= 0 {
   364			b.lastByte = int(line[i])
   365			b.lastRuneSize = -1
   366		}
   367	
   368		return
   369	}
   370	
   371	// ReadLine is a low-level line-reading primitive. Most callers should use
   372	// ReadBytes('\n') or ReadString('\n') instead or use a Scanner.
   373	//
   374	// ReadLine tries to return a single line, not including the end-of-line bytes.
   375	// If the line was too long for the buffer then isPrefix is set and the
   376	// beginning of the line is returned. The rest of the line will be returned
   377	// from future calls. isPrefix will be false when returning the last fragment
   378	// of the line. The returned buffer is only valid until the next call to
   379	// ReadLine. ReadLine either returns a non-nil line or it returns an error,
   380	// never both.
   381	//
   382	// The text returned from ReadLine does not include the line end ("\r\n" or "\n").
   383	// No indication or error is given if the input ends without a final line end.
   384	// Calling UnreadByte after ReadLine will always unread the last byte read
   385	// (possibly a character belonging to the line end) even if that byte is not
   386	// part of the line returned by ReadLine.
   387	func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) {
   388		line, err = b.ReadSlice('\n')
   389		if err == ErrBufferFull {
   390			// Handle the case where "\r\n" straddles the buffer.
   391			if len(line) > 0 && line[len(line)-1] == '\r' {
   392				// Put the '\r' back on buf and drop it from line.
   393				// Let the next call to ReadLine check for "\r\n".
   394				if b.r == 0 {
   395					// should be unreachable
   396					panic("bufio: tried to rewind past start of buffer")
   397				}
   398				b.r--
   399				line = line[:len(line)-1]
   400			}
   401			return line, true, nil
   402		}
   403	
   404		if len(line) == 0 {
   405			if err != nil {
   406				line = nil
   407			}
   408			return
   409		}
   410		err = nil
   411	
   412		if line[len(line)-1] == '\n' {
   413			drop := 1
   414			if len(line) > 1 && line[len(line)-2] == '\r' {
   415				drop = 2
   416			}
   417			line = line[:len(line)-drop]
   418		}
   419		return
   420	}
   421	
   422	// ReadBytes reads until the first occurrence of delim in the input,
   423	// returning a slice containing the data up to and including the delimiter.
   424	// If ReadBytes encounters an error before finding a delimiter,
   425	// it returns the data read before the error and the error itself (often io.EOF).
   426	// ReadBytes returns err != nil if and only if the returned data does not end in
   427	// delim.
   428	// For simple uses, a Scanner may be more convenient.
   429	func (b *Reader) ReadBytes(delim byte) ([]byte, error) {
   430		// Use ReadSlice to look for array,
   431		// accumulating full buffers.
   432		var frag []byte
   433		var full [][]byte
   434		var err error
   435		for {
   436			var e error
   437			frag, e = b.ReadSlice(delim)
   438			if e == nil { // got final fragment
   439				break
   440			}
   441			if e != ErrBufferFull { // unexpected error
   442				err = e
   443				break
   444			}
   445	
   446			// Make a copy of the buffer.
   447			buf := make([]byte, len(frag))
   448			copy(buf, frag)
   449			full = append(full, buf)
   450		}
   451	
   452		// Allocate new buffer to hold the full pieces and the fragment.
   453		n := 0
   454		for i := range full {
   455			n += len(full[i])
   456		}
   457		n += len(frag)
   458	
   459		// Copy full pieces and fragment in.
   460		buf := make([]byte, n)
   461		n = 0
   462		for i := range full {
   463			n += copy(buf[n:], full[i])
   464		}
   465		copy(buf[n:], frag)
   466		return buf, err
   467	}
   468	
   469	// ReadString reads until the first occurrence of delim in the input,
   470	// returning a string containing the data up to and including the delimiter.
   471	// If ReadString encounters an error before finding a delimiter,
   472	// it returns the data read before the error and the error itself (often io.EOF).
   473	// ReadString returns err != nil if and only if the returned data does not end in
   474	// delim.
   475	// For simple uses, a Scanner may be more convenient.
   476	func (b *Reader) ReadString(delim byte) (string, error) {
   477		bytes, err := b.ReadBytes(delim)
   478		return string(bytes), err
   479	}
   480	
   481	// WriteTo implements io.WriterTo.
   482	// This may make multiple calls to the Read method of the underlying Reader.
   483	// If the underlying reader supports the WriteTo method,
   484	// this calls the underlying WriteTo without buffering.
   485	func (b *Reader) WriteTo(w io.Writer) (n int64, err error) {
   486		n, err = b.writeBuf(w)
   487		if err != nil {
   488			return
   489		}
   490	
   491		if r, ok := b.rd.(io.WriterTo); ok {
   492			m, err := r.WriteTo(w)
   493			n += m
   494			return n, err
   495		}
   496	
   497		if w, ok := w.(io.ReaderFrom); ok {
   498			m, err := w.ReadFrom(b.rd)
   499			n += m
   500			return n, err
   501		}
   502	
   503		if b.w-b.r < len(b.buf) {
   504			b.fill() // buffer not full
   505		}
   506	
   507		for b.r < b.w {
   508			// b.r < b.w => buffer is not empty
   509			m, err := b.writeBuf(w)
   510			n += m
   511			if err != nil {
   512				return n, err
   513			}
   514			b.fill() // buffer is empty
   515		}
   516	
   517		if b.err == io.EOF {
   518			b.err = nil
   519		}
   520	
   521		return n, b.readErr()
   522	}
   523	
   524	var errNegativeWrite = errors.New("bufio: writer returned negative count from Write")
   525	
   526	// writeBuf writes the Reader's buffer to the writer.
   527	func (b *Reader) writeBuf(w io.Writer) (int64, error) {
   528		n, err := w.Write(b.buf[b.r:b.w])
   529		if n < 0 {
   530			panic(errNegativeWrite)
   531		}
   532		b.r += n
   533		return int64(n), err
   534	}
   535	
   536	// buffered output
   537	
   538	// Writer implements buffering for an io.Writer object.
   539	// If an error occurs writing to a Writer, no more data will be
   540	// accepted and all subsequent writes, and Flush, will return the error.
   541	// After all data has been written, the client should call the
   542	// Flush method to guarantee all data has been forwarded to
   543	// the underlying io.Writer.
   544	type Writer struct {
   545		err error
   546		buf []byte
   547		n   int
   548		wr  io.Writer
   549	}
   550	
   551	// NewWriterSize returns a new Writer whose buffer has at least the specified
   552	// size. If the argument io.Writer is already a Writer with large enough
   553	// size, it returns the underlying Writer.
   554	func NewWriterSize(w io.Writer, size int) *Writer {
   555		// Is it already a Writer?
   556		b, ok := w.(*Writer)
   557		if ok && len(b.buf) >= size {
   558			return b
   559		}
   560		if size <= 0 {
   561			size = defaultBufSize
   562		}
   563		return &Writer{
   564			buf: make([]byte, size),
   565			wr:  w,
   566		}
   567	}
   568	
   569	// NewWriter returns a new Writer whose buffer has the default size.
   570	func NewWriter(w io.Writer) *Writer {
   571		return NewWriterSize(w, defaultBufSize)
   572	}
   573	
   574	// Size returns the size of the underlying buffer in bytes.
   575	func (b *Writer) Size() int { return len(b.buf) }
   576	
   577	// Reset discards any unflushed buffered data, clears any error, and
   578	// resets b to write its output to w.
   579	func (b *Writer) Reset(w io.Writer) {
   580		b.err = nil
   581		b.n = 0
   582		b.wr = w
   583	}
   584	
   585	// Flush writes any buffered data to the underlying io.Writer.
   586	func (b *Writer) Flush() error {
   587		if b.err != nil {
   588			return b.err
   589		}
   590		if b.n == 0 {
   591			return nil
   592		}
   593		n, err := b.wr.Write(b.buf[0:b.n])
   594		if n < b.n && err == nil {
   595			err = io.ErrShortWrite
   596		}
   597		if err != nil {
   598			if n > 0 && n < b.n {
   599				copy(b.buf[0:b.n-n], b.buf[n:b.n])
   600			}
   601			b.n -= n
   602			b.err = err
   603			return err
   604		}
   605		b.n = 0
   606		return nil
   607	}
   608	
   609	// Available returns how many bytes are unused in the buffer.
   610	func (b *Writer) Available() int { return len(b.buf) - b.n }
   611	
   612	// Buffered returns the number of bytes that have been written into the current buffer.
   613	func (b *Writer) Buffered() int { return b.n }
   614	
   615	// Write writes the contents of p into the buffer.
   616	// It returns the number of bytes written.
   617	// If nn < len(p), it also returns an error explaining
   618	// why the write is short.
   619	func (b *Writer) Write(p []byte) (nn int, err error) {
   620		for len(p) > b.Available() && b.err == nil {
   621			var n int
   622			if b.Buffered() == 0 {
   623				// Large write, empty buffer.
   624				// Write directly from p to avoid copy.
   625				n, b.err = b.wr.Write(p)
   626			} else {
   627				n = copy(b.buf[b.n:], p)
   628				b.n += n
   629				b.Flush()
   630			}
   631			nn += n
   632			p = p[n:]
   633		}
   634		if b.err != nil {
   635			return nn, b.err
   636		}
   637		n := copy(b.buf[b.n:], p)
   638		b.n += n
   639		nn += n
   640		return nn, nil
   641	}
   642	
   643	// WriteByte writes a single byte.
   644	func (b *Writer) WriteByte(c byte) error {
   645		if b.err != nil {
   646			return b.err
   647		}
   648		if b.Available() <= 0 && b.Flush() != nil {
   649			return b.err
   650		}
   651		b.buf[b.n] = c
   652		b.n++
   653		return nil
   654	}
   655	
   656	// WriteRune writes a single Unicode code point, returning
   657	// the number of bytes written and any error.
   658	func (b *Writer) WriteRune(r rune) (size int, err error) {
   659		if r < utf8.RuneSelf {
   660			err = b.WriteByte(byte(r))
   661			if err != nil {
   662				return 0, err
   663			}
   664			return 1, nil
   665		}
   666		if b.err != nil {
   667			return 0, b.err
   668		}
   669		n := b.Available()
   670		if n < utf8.UTFMax {
   671			if b.Flush(); b.err != nil {
   672				return 0, b.err
   673			}
   674			n = b.Available()
   675			if n < utf8.UTFMax {
   676				// Can only happen if buffer is silly small.
   677				return b.WriteString(string(r))
   678			}
   679		}
   680		size = utf8.EncodeRune(b.buf[b.n:], r)
   681		b.n += size
   682		return size, nil
   683	}
   684	
   685	// WriteString writes a string.
   686	// It returns the number of bytes written.
   687	// If the count is less than len(s), it also returns an error explaining
   688	// why the write is short.
   689	func (b *Writer) WriteString(s string) (int, error) {
   690		nn := 0
   691		for len(s) > b.Available() && b.err == nil {
   692			n := copy(b.buf[b.n:], s)
   693			b.n += n
   694			nn += n
   695			s = s[n:]
   696			b.Flush()
   697		}
   698		if b.err != nil {
   699			return nn, b.err
   700		}
   701		n := copy(b.buf[b.n:], s)
   702		b.n += n
   703		nn += n
   704		return nn, nil
   705	}
   706	
   707	// ReadFrom implements io.ReaderFrom. If the underlying writer
   708	// supports the ReadFrom method, and b has no buffered data yet,
   709	// this calls the underlying ReadFrom without buffering.
   710	func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) {
   711		if b.Buffered() == 0 {
   712			if w, ok := b.wr.(io.ReaderFrom); ok {
   713				return w.ReadFrom(r)
   714			}
   715		}
   716		var m int
   717		for {
   718			if b.Available() == 0 {
   719				if err1 := b.Flush(); err1 != nil {
   720					return n, err1
   721				}
   722			}
   723			nr := 0
   724			for nr < maxConsecutiveEmptyReads {
   725				m, err = r.Read(b.buf[b.n:])
   726				if m != 0 || err != nil {
   727					break
   728				}
   729				nr++
   730			}
   731			if nr == maxConsecutiveEmptyReads {
   732				return n, io.ErrNoProgress
   733			}
   734			b.n += m
   735			n += int64(m)
   736			if err != nil {
   737				break
   738			}
   739		}
   740		if err == io.EOF {
   741			// If we filled the buffer exactly, flush preemptively.
   742			if b.Available() == 0 {
   743				err = b.Flush()
   744			} else {
   745				err = nil
   746			}
   747		}
   748		return n, err
   749	}
   750	
   751	// buffered input and output
   752	
   753	// ReadWriter stores pointers to a Reader and a Writer.
   754	// It implements io.ReadWriter.
   755	type ReadWriter struct {
   756		*Reader
   757		*Writer
   758	}
   759	
   760	// NewReadWriter allocates a new ReadWriter that dispatches to r and w.
   761	func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
   762		return &ReadWriter{r, w}
   763	}
   764	

View as plain text