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