Source file src/io/io.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 io provides basic interfaces to I/O primitives.
     6  // Its primary job is to wrap existing implementations of such primitives,
     7  // such as those in package os, into shared public interfaces that
     8  // abstract the functionality, plus some other related primitives.
     9  //
    10  // Because these interfaces and primitives wrap lower-level operations with
    11  // various implementations, unless otherwise informed clients should not
    12  // assume they are safe for parallel execution.
    13  package io
    14  
    15  import (
    16  	"errors"
    17  	"sync"
    18  )
    19  
    20  // Seek whence values.
    21  const (
    22  	SeekStart   = 0 // seek relative to the origin of the file
    23  	SeekCurrent = 1 // seek relative to the current offset
    24  	SeekEnd     = 2 // seek relative to the end
    25  )
    26  
    27  // ErrShortWrite means that a write accepted fewer bytes than requested
    28  // but failed to return an explicit error.
    29  var ErrShortWrite = errors.New("short write")
    30  
    31  // errInvalidWrite means that a write returned an impossible count.
    32  var errInvalidWrite = errors.New("invalid write result")
    33  
    34  // ErrShortBuffer means that a read required a longer buffer than was provided.
    35  var ErrShortBuffer = errors.New("short buffer")
    36  
    37  // EOF is the error returned by Read when no more input is available.
    38  // (Read must return EOF itself, not an error wrapping EOF,
    39  // because callers will test for EOF using ==.)
    40  // Functions should return EOF only to signal a graceful end of input.
    41  // If the EOF occurs unexpectedly in a structured data stream,
    42  // the appropriate error is either ErrUnexpectedEOF or some other error
    43  // giving more detail.
    44  var EOF = errors.New("EOF")
    45  
    46  // ErrUnexpectedEOF means that EOF was encountered in the
    47  // middle of reading a fixed-size block or data structure.
    48  var ErrUnexpectedEOF = errors.New("unexpected EOF")
    49  
    50  // ErrNoProgress is returned by some clients of a Reader when
    51  // many calls to Read have failed to return any data or error,
    52  // usually the sign of a broken Reader implementation.
    53  var ErrNoProgress = errors.New("multiple Read calls return no data or error")
    54  
    55  // Reader is the interface that wraps the basic Read method.
    56  //
    57  // Read reads up to len(p) bytes into p. It returns the number of bytes
    58  // read (0 <= n <= len(p)) and any error encountered. Even if Read
    59  // returns n < len(p), it may use all of p as scratch space during the call.
    60  // If some data is available but not len(p) bytes, Read conventionally
    61  // returns what is available instead of waiting for more.
    62  //
    63  // When Read encounters an error or end-of-file condition after
    64  // successfully reading n > 0 bytes, it returns the number of
    65  // bytes read. It may return the (non-nil) error from the same call
    66  // or return the error (and n == 0) from a subsequent call.
    67  // An instance of this general case is that a Reader returning
    68  // a non-zero number of bytes at the end of the input stream may
    69  // return either err == EOF or err == nil. The next Read should
    70  // return 0, EOF.
    71  //
    72  // Callers should always process the n > 0 bytes returned before
    73  // considering the error err. Doing so correctly handles I/O errors
    74  // that happen after reading some bytes and also both of the
    75  // allowed EOF behaviors.
    76  //
    77  // Implementations of Read are discouraged from returning a
    78  // zero byte count with a nil error, except when len(p) == 0.
    79  // Callers should treat a return of 0 and nil as indicating that
    80  // nothing happened; in particular it does not indicate EOF.
    81  //
    82  // Implementations must not retain p.
    83  type Reader interface {
    84  	Read(p []byte) (n int, err error)
    85  }
    86  
    87  // Writer is the interface that wraps the basic Write method.
    88  //
    89  // Write writes len(p) bytes from p to the underlying data stream.
    90  // It returns the number of bytes written from p (0 <= n <= len(p))
    91  // and any error encountered that caused the write to stop early.
    92  // Write must return a non-nil error if it returns n < len(p).
    93  // Write must not modify the slice data, even temporarily.
    94  //
    95  // Implementations must not retain p.
    96  type Writer interface {
    97  	Write(p []byte) (n int, err error)
    98  }
    99  
   100  // Closer is the interface that wraps the basic Close method.
   101  //
   102  // The behavior of Close after the first call is undefined.
   103  // Specific implementations may document their own behavior.
   104  type Closer interface {
   105  	Close() error
   106  }
   107  
   108  // Seeker is the interface that wraps the basic Seek method.
   109  //
   110  // Seek sets the offset for the next Read or Write to offset,
   111  // interpreted according to whence:
   112  // SeekStart means relative to the start of the file,
   113  // SeekCurrent means relative to the current offset, and
   114  // SeekEnd means relative to the end
   115  // (for example, offset = -2 specifies the penultimate byte of the file).
   116  // Seek returns the new offset relative to the start of the
   117  // file or an error, if any.
   118  //
   119  // Seeking to an offset before the start of the file is an error.
   120  // Seeking to any positive offset may be allowed, but if the new offset exceeds
   121  // the size of the underlying object the behavior of subsequent I/O operations
   122  // is implementation-dependent.
   123  type Seeker interface {
   124  	Seek(offset int64, whence int) (int64, error)
   125  }
   126  
   127  // ReadWriter is the interface that groups the basic Read and Write methods.
   128  type ReadWriter interface {
   129  	Reader
   130  	Writer
   131  }
   132  
   133  // ReadCloser is the interface that groups the basic Read and Close methods.
   134  type ReadCloser interface {
   135  	Reader
   136  	Closer
   137  }
   138  
   139  // WriteCloser is the interface that groups the basic Write and Close methods.
   140  type WriteCloser interface {
   141  	Writer
   142  	Closer
   143  }
   144  
   145  // ReadWriteCloser is the interface that groups the basic Read, Write and Close methods.
   146  type ReadWriteCloser interface {
   147  	Reader
   148  	Writer
   149  	Closer
   150  }
   151  
   152  // ReadSeeker is the interface that groups the basic Read and Seek methods.
   153  type ReadSeeker interface {
   154  	Reader
   155  	Seeker
   156  }
   157  
   158  // ReadSeekCloser is the interface that groups the basic Read, Seek and Close
   159  // methods.
   160  type ReadSeekCloser interface {
   161  	Reader
   162  	Seeker
   163  	Closer
   164  }
   165  
   166  // WriteSeeker is the interface that groups the basic Write and Seek methods.
   167  type WriteSeeker interface {
   168  	Writer
   169  	Seeker
   170  }
   171  
   172  // ReadWriteSeeker is the interface that groups the basic Read, Write and Seek methods.
   173  type ReadWriteSeeker interface {
   174  	Reader
   175  	Writer
   176  	Seeker
   177  }
   178  
   179  // ReaderFrom is the interface that wraps the ReadFrom method.
   180  //
   181  // ReadFrom reads data from r until EOF or error.
   182  // The return value n is the number of bytes read.
   183  // Any error except EOF encountered during the read is also returned.
   184  //
   185  // The Copy function uses ReaderFrom if available.
   186  type ReaderFrom interface {
   187  	ReadFrom(r Reader) (n int64, err error)
   188  }
   189  
   190  // WriterTo is the interface that wraps the WriteTo method.
   191  //
   192  // WriteTo writes data to w until there's no more data to write or
   193  // when an error occurs. The return value n is the number of bytes
   194  // written. Any error encountered during the write is also returned.
   195  //
   196  // The Copy function uses WriterTo if available.
   197  type WriterTo interface {
   198  	WriteTo(w Writer) (n int64, err error)
   199  }
   200  
   201  // ReaderAt is the interface that wraps the basic ReadAt method.
   202  //
   203  // ReadAt reads len(p) bytes into p starting at offset off in the
   204  // underlying input source. It returns the number of bytes
   205  // read (0 <= n <= len(p)) and any error encountered.
   206  //
   207  // When ReadAt returns n < len(p), it returns a non-nil error
   208  // explaining why more bytes were not returned. In this respect,
   209  // ReadAt is stricter than Read.
   210  //
   211  // Even if ReadAt returns n < len(p), it may use all of p as scratch
   212  // space during the call. If some data is available but not len(p) bytes,
   213  // ReadAt blocks until either all the data is available or an error occurs.
   214  // In this respect ReadAt is different from Read.
   215  //
   216  // If the n = len(p) bytes returned by ReadAt are at the end of the
   217  // input source, ReadAt may return either err == EOF or err == nil.
   218  //
   219  // If ReadAt is reading from an input source with a seek offset,
   220  // ReadAt should not affect nor be affected by the underlying
   221  // seek offset.
   222  //
   223  // Clients of ReadAt can execute parallel ReadAt calls on the
   224  // same input source.
   225  //
   226  // Implementations must not retain p.
   227  type ReaderAt interface {
   228  	ReadAt(p []byte, off int64) (n int, err error)
   229  }
   230  
   231  // WriterAt is the interface that wraps the basic WriteAt method.
   232  //
   233  // WriteAt writes len(p) bytes from p to the underlying data stream
   234  // at offset off. It returns the number of bytes written from p (0 <= n <= len(p))
   235  // and any error encountered that caused the write to stop early.
   236  // WriteAt must return a non-nil error if it returns n < len(p).
   237  //
   238  // If WriteAt is writing to a destination with a seek offset,
   239  // WriteAt should not affect nor be affected by the underlying
   240  // seek offset.
   241  //
   242  // Clients of WriteAt can execute parallel WriteAt calls on the same
   243  // destination if the ranges do not overlap.
   244  //
   245  // Implementations must not retain p.
   246  type WriterAt interface {
   247  	WriteAt(p []byte, off int64) (n int, err error)
   248  }
   249  
   250  // ByteReader is the interface that wraps the ReadByte method.
   251  //
   252  // ReadByte reads and returns the next byte from the input or
   253  // any error encountered. If ReadByte returns an error, no input
   254  // byte was consumed, and the returned byte value is undefined.
   255  //
   256  // ReadByte provides an efficient interface for byte-at-time
   257  // processing. A Reader that does not implement  ByteReader
   258  // can be wrapped using bufio.NewReader to add this method.
   259  type ByteReader interface {
   260  	ReadByte() (byte, error)
   261  }
   262  
   263  // ByteScanner is the interface that adds the UnreadByte method to the
   264  // basic ReadByte method.
   265  //
   266  // UnreadByte causes the next call to ReadByte to return the last byte read.
   267  // If the last operation was not a successful call to ReadByte, UnreadByte may
   268  // return an error, unread the last byte read (or the byte prior to the
   269  // last-unread byte), or (in implementations that support the Seeker interface)
   270  // seek to one byte before the current offset.
   271  type ByteScanner interface {
   272  	ByteReader
   273  	UnreadByte() error
   274  }
   275  
   276  // ByteWriter is the interface that wraps the WriteByte method.
   277  type ByteWriter interface {
   278  	WriteByte(c byte) error
   279  }
   280  
   281  // RuneReader is the interface that wraps the ReadRune method.
   282  //
   283  // ReadRune reads a single encoded Unicode character
   284  // and returns the rune and its size in bytes. If no character is
   285  // available, err will be set.
   286  type RuneReader interface {
   287  	ReadRune() (r rune, size int, err error)
   288  }
   289  
   290  // RuneScanner is the interface that adds the UnreadRune method to the
   291  // basic ReadRune method.
   292  //
   293  // UnreadRune causes the next call to ReadRune to return the last rune read.
   294  // If the last operation was not a successful call to ReadRune, UnreadRune may
   295  // return an error, unread the last rune read (or the rune prior to the
   296  // last-unread rune), or (in implementations that support the Seeker interface)
   297  // seek to the start of the rune before the current offset.
   298  type RuneScanner interface {
   299  	RuneReader
   300  	UnreadRune() error
   301  }
   302  
   303  // StringWriter is the interface that wraps the WriteString method.
   304  type StringWriter interface {
   305  	WriteString(s string) (n int, err error)
   306  }
   307  
   308  // WriteString writes the contents of the string s to w, which accepts a slice of bytes.
   309  // If w implements StringWriter, its WriteString method is invoked directly.
   310  // Otherwise, w.Write is called exactly once.
   311  func WriteString(w Writer, s string) (n int, err error) {
   312  	if sw, ok := w.(StringWriter); ok {
   313  		return sw.WriteString(s)
   314  	}
   315  	return w.Write([]byte(s))
   316  }
   317  
   318  // ReadAtLeast reads from r into buf until it has read at least min bytes.
   319  // It returns the number of bytes copied and an error if fewer bytes were read.
   320  // The error is EOF only if no bytes were read.
   321  // If an EOF happens after reading fewer than min bytes,
   322  // ReadAtLeast returns ErrUnexpectedEOF.
   323  // If min is greater than the length of buf, ReadAtLeast returns ErrShortBuffer.
   324  // On return, n >= min if and only if err == nil.
   325  // If r returns an error having read at least min bytes, the error is dropped.
   326  func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) {
   327  	if len(buf) < min {
   328  		return 0, ErrShortBuffer
   329  	}
   330  	for n < min && err == nil {
   331  		var nn int
   332  		nn, err = r.Read(buf[n:])
   333  		n += nn
   334  	}
   335  	if n >= min {
   336  		err = nil
   337  	} else if n > 0 && err == EOF {
   338  		err = ErrUnexpectedEOF
   339  	}
   340  	return
   341  }
   342  
   343  // ReadFull reads exactly len(buf) bytes from r into buf.
   344  // It returns the number of bytes copied and an error if fewer bytes were read.
   345  // The error is EOF only if no bytes were read.
   346  // If an EOF happens after reading some but not all the bytes,
   347  // ReadFull returns ErrUnexpectedEOF.
   348  // On return, n == len(buf) if and only if err == nil.
   349  // If r returns an error having read at least len(buf) bytes, the error is dropped.
   350  func ReadFull(r Reader, buf []byte) (n int, err error) {
   351  	return ReadAtLeast(r, buf, len(buf))
   352  }
   353  
   354  // CopyN copies n bytes (or until an error) from src to dst.
   355  // It returns the number of bytes copied and the earliest
   356  // error encountered while copying.
   357  // On return, written == n if and only if err == nil.
   358  //
   359  // If dst implements the ReaderFrom interface,
   360  // the copy is implemented using it.
   361  func CopyN(dst Writer, src Reader, n int64) (written int64, err error) {
   362  	written, err = Copy(dst, LimitReader(src, n))
   363  	if written == n {
   364  		return n, nil
   365  	}
   366  	if written < n && err == nil {
   367  		// src stopped early; must have been EOF.
   368  		err = EOF
   369  	}
   370  	return
   371  }
   372  
   373  // Copy copies from src to dst until either EOF is reached
   374  // on src or an error occurs. It returns the number of bytes
   375  // copied and the first error encountered while copying, if any.
   376  //
   377  // A successful Copy returns err == nil, not err == EOF.
   378  // Because Copy is defined to read from src until EOF, it does
   379  // not treat an EOF from Read as an error to be reported.
   380  //
   381  // If src implements the WriterTo interface,
   382  // the copy is implemented by calling src.WriteTo(dst).
   383  // Otherwise, if dst implements the ReaderFrom interface,
   384  // the copy is implemented by calling dst.ReadFrom(src).
   385  func Copy(dst Writer, src Reader) (written int64, err error) {
   386  	return copyBuffer(dst, src, nil)
   387  }
   388  
   389  // CopyBuffer is identical to Copy except that it stages through the
   390  // provided buffer (if one is required) rather than allocating a
   391  // temporary one. If buf is nil, one is allocated; otherwise if it has
   392  // zero length, CopyBuffer panics.
   393  //
   394  // If either src implements WriterTo or dst implements ReaderFrom,
   395  // buf will not be used to perform the copy.
   396  func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
   397  	if buf != nil && len(buf) == 0 {
   398  		panic("empty buffer in CopyBuffer")
   399  	}
   400  	return copyBuffer(dst, src, buf)
   401  }
   402  
   403  // copyBuffer is the actual implementation of Copy and CopyBuffer.
   404  // if buf is nil, one is allocated.
   405  func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
   406  	// If the reader has a WriteTo method, use it to do the copy.
   407  	// Avoids an allocation and a copy.
   408  	if wt, ok := src.(WriterTo); ok {
   409  		return wt.WriteTo(dst)
   410  	}
   411  	// Similarly, if the writer has a ReadFrom method, use it to do the copy.
   412  	if rt, ok := dst.(ReaderFrom); ok {
   413  		return rt.ReadFrom(src)
   414  	}
   415  	if buf == nil {
   416  		size := 32 * 1024
   417  		if l, ok := src.(*LimitedReader); ok && int64(size) > l.N {
   418  			if l.N < 1 {
   419  				size = 1
   420  			} else {
   421  				size = int(l.N)
   422  			}
   423  		}
   424  		buf = make([]byte, size)
   425  	}
   426  	for {
   427  		nr, er := src.Read(buf)
   428  		if nr > 0 {
   429  			nw, ew := dst.Write(buf[0:nr])
   430  			if nw < 0 || nr < nw {
   431  				nw = 0
   432  				if ew == nil {
   433  					ew = errInvalidWrite
   434  				}
   435  			}
   436  			written += int64(nw)
   437  			if ew != nil {
   438  				err = ew
   439  				break
   440  			}
   441  			if nr != nw {
   442  				err = ErrShortWrite
   443  				break
   444  			}
   445  		}
   446  		if er != nil {
   447  			if er != EOF {
   448  				err = er
   449  			}
   450  			break
   451  		}
   452  	}
   453  	return written, err
   454  }
   455  
   456  // LimitReader returns a Reader that reads from r
   457  // but stops with EOF after n bytes.
   458  // The underlying implementation is a *LimitedReader.
   459  func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n} }
   460  
   461  // A LimitedReader reads from R but limits the amount of
   462  // data returned to just N bytes. Each call to Read
   463  // updates N to reflect the new amount remaining.
   464  // Read returns EOF when N <= 0 or when the underlying R returns EOF.
   465  type LimitedReader struct {
   466  	R Reader // underlying reader
   467  	N int64  // max bytes remaining
   468  }
   469  
   470  func (l *LimitedReader) Read(p []byte) (n int, err error) {
   471  	if l.N <= 0 {
   472  		return 0, EOF
   473  	}
   474  	if int64(len(p)) > l.N {
   475  		p = p[0:l.N]
   476  	}
   477  	n, err = l.R.Read(p)
   478  	l.N -= int64(n)
   479  	return
   480  }
   481  
   482  // NewSectionReader returns a SectionReader that reads from r
   483  // starting at offset off and stops with EOF after n bytes.
   484  func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader {
   485  	var remaining int64
   486  	const maxint64 = 1<<63 - 1
   487  	if off <= maxint64-n {
   488  		remaining = n + off
   489  	} else {
   490  		// Overflow, with no way to return error.
   491  		// Assume we can read up to an offset of 1<<63 - 1.
   492  		remaining = maxint64
   493  	}
   494  	return &SectionReader{r, off, off, remaining}
   495  }
   496  
   497  // SectionReader implements Read, Seek, and ReadAt on a section
   498  // of an underlying ReaderAt.
   499  type SectionReader struct {
   500  	r     ReaderAt
   501  	base  int64
   502  	off   int64
   503  	limit int64
   504  }
   505  
   506  func (s *SectionReader) Read(p []byte) (n int, err error) {
   507  	if s.off >= s.limit {
   508  		return 0, EOF
   509  	}
   510  	if max := s.limit - s.off; int64(len(p)) > max {
   511  		p = p[0:max]
   512  	}
   513  	n, err = s.r.ReadAt(p, s.off)
   514  	s.off += int64(n)
   515  	return
   516  }
   517  
   518  var errWhence = errors.New("Seek: invalid whence")
   519  var errOffset = errors.New("Seek: invalid offset")
   520  
   521  func (s *SectionReader) Seek(offset int64, whence int) (int64, error) {
   522  	switch whence {
   523  	default:
   524  		return 0, errWhence
   525  	case SeekStart:
   526  		offset += s.base
   527  	case SeekCurrent:
   528  		offset += s.off
   529  	case SeekEnd:
   530  		offset += s.limit
   531  	}
   532  	if offset < s.base {
   533  		return 0, errOffset
   534  	}
   535  	s.off = offset
   536  	return offset - s.base, nil
   537  }
   538  
   539  func (s *SectionReader) ReadAt(p []byte, off int64) (n int, err error) {
   540  	if off < 0 || off >= s.limit-s.base {
   541  		return 0, EOF
   542  	}
   543  	off += s.base
   544  	if max := s.limit - off; int64(len(p)) > max {
   545  		p = p[0:max]
   546  		n, err = s.r.ReadAt(p, off)
   547  		if err == nil {
   548  			err = EOF
   549  		}
   550  		return n, err
   551  	}
   552  	return s.r.ReadAt(p, off)
   553  }
   554  
   555  // Size returns the size of the section in bytes.
   556  func (s *SectionReader) Size() int64 { return s.limit - s.base }
   557  
   558  // TeeReader returns a Reader that writes to w what it reads from r.
   559  // All reads from r performed through it are matched with
   560  // corresponding writes to w. There is no internal buffering -
   561  // the write must complete before the read completes.
   562  // Any error encountered while writing is reported as a read error.
   563  func TeeReader(r Reader, w Writer) Reader {
   564  	return &teeReader{r, w}
   565  }
   566  
   567  type teeReader struct {
   568  	r Reader
   569  	w Writer
   570  }
   571  
   572  func (t *teeReader) Read(p []byte) (n int, err error) {
   573  	n, err = t.r.Read(p)
   574  	if n > 0 {
   575  		if n, err := t.w.Write(p[:n]); err != nil {
   576  			return n, err
   577  		}
   578  	}
   579  	return
   580  }
   581  
   582  // Discard is a Writer on which all Write calls succeed
   583  // without doing anything.
   584  var Discard Writer = discard{}
   585  
   586  type discard struct{}
   587  
   588  // discard implements ReaderFrom as an optimization so Copy to
   589  // io.Discard can avoid doing unnecessary work.
   590  var _ ReaderFrom = discard{}
   591  
   592  func (discard) Write(p []byte) (int, error) {
   593  	return len(p), nil
   594  }
   595  
   596  func (discard) WriteString(s string) (int, error) {
   597  	return len(s), nil
   598  }
   599  
   600  var blackHolePool = sync.Pool{
   601  	New: func() any {
   602  		b := make([]byte, 8192)
   603  		return &b
   604  	},
   605  }
   606  
   607  func (discard) ReadFrom(r Reader) (n int64, err error) {
   608  	bufp := blackHolePool.Get().(*[]byte)
   609  	readSize := 0
   610  	for {
   611  		readSize, err = r.Read(*bufp)
   612  		n += int64(readSize)
   613  		if err != nil {
   614  			blackHolePool.Put(bufp)
   615  			if err == EOF {
   616  				return n, nil
   617  			}
   618  			return
   619  		}
   620  	}
   621  }
   622  
   623  // NopCloser returns a ReadCloser with a no-op Close method wrapping
   624  // the provided Reader r.
   625  // If r implements WriterTo, the returned ReadCloser will implement WriterTo
   626  // by forwarding calls to r.
   627  func NopCloser(r Reader) ReadCloser {
   628  	if _, ok := r.(WriterTo); ok {
   629  		return nopCloserWriterTo{r}
   630  	}
   631  	return nopCloser{r}
   632  }
   633  
   634  type nopCloser struct {
   635  	Reader
   636  }
   637  
   638  func (nopCloser) Close() error { return nil }
   639  
   640  type nopCloserWriterTo struct {
   641  	Reader
   642  }
   643  
   644  func (nopCloserWriterTo) Close() error { return nil }
   645  
   646  func (c nopCloserWriterTo) WriteTo(w Writer) (n int64, err error) {
   647  	return c.Reader.(WriterTo).WriteTo(w)
   648  }
   649  
   650  // ReadAll reads from r until an error or EOF and returns the data it read.
   651  // A successful call returns err == nil, not err == EOF. Because ReadAll is
   652  // defined to read from src until EOF, it does not treat an EOF from Read
   653  // as an error to be reported.
   654  func ReadAll(r Reader) ([]byte, error) {
   655  	b := make([]byte, 0, 512)
   656  	for {
   657  		if len(b) == cap(b) {
   658  			// Add more capacity (let append pick how much).
   659  			b = append(b, 0)[:len(b)]
   660  		}
   661  		n, err := r.Read(b[len(b):cap(b)])
   662  		b = b[:len(b)+n]
   663  		if err != nil {
   664  			if err == EOF {
   665  				err = nil
   666  			}
   667  			return b, err
   668  		}
   669  	}
   670  }
   671  

View as plain text