Source file
src/bufio/bufio.go
Documentation: bufio
1
2
3
4
5
6
7
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
29
30
31 type Reader struct {
32 buf []byte
33 rd io.Reader
34 r, w int
35 err error
36 lastByte int
37 lastRuneSize int
38 }
39
40 const minReadBufferSize = 16
41 const maxConsecutiveEmptyReads = 100
42
43
44
45
46 func NewReaderSize(rd io.Reader, size int) *Reader {
47
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
61 func NewReader(rd io.Reader) *Reader {
62 return NewReaderSize(rd, defaultBufSize)
63 }
64
65
66 func (r *Reader) Size() int { return len(r.buf) }
67
68
69
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
86 func (b *Reader) fill() {
87
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
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
123
124
125
126 func (b *Reader) Peek(n int) ([]byte, error) {
127 if n < 0 {
128 return nil, ErrNegativeCount
129 }
130
131 for b.w-b.r < n && b.w-b.r < len(b.buf) && b.err == nil {
132 b.fill()
133 }
134
135 if n > len(b.buf) {
136 return b.buf[b.r:b.w], ErrBufferFull
137 }
138
139
140 var err error
141 if avail := b.w - b.r; avail < n {
142
143 n = avail
144 err = b.readErr()
145 if err == nil {
146 err = ErrBufferFull
147 }
148 }
149 return b.buf[b.r : b.r+n], err
150 }
151
152
153
154
155
156
157 func (b *Reader) Discard(n int) (discarded int, err error) {
158 if n < 0 {
159 return 0, ErrNegativeCount
160 }
161 if n == 0 {
162 return
163 }
164 remain := n
165 for {
166 skip := b.Buffered()
167 if skip == 0 {
168 b.fill()
169 skip = b.Buffered()
170 }
171 if skip > remain {
172 skip = remain
173 }
174 b.r += skip
175 remain -= skip
176 if remain == 0 {
177 return n, nil
178 }
179 if b.err != nil {
180 return n - remain, b.readErr()
181 }
182 }
183 }
184
185
186
187
188
189
190 func (b *Reader) Read(p []byte) (n int, err error) {
191 n = len(p)
192 if n == 0 {
193 return 0, b.readErr()
194 }
195 if b.r == b.w {
196 if b.err != nil {
197 return 0, b.readErr()
198 }
199 if len(p) >= len(b.buf) {
200
201
202 n, b.err = b.rd.Read(p)
203 if n < 0 {
204 panic(errNegativeRead)
205 }
206 if n > 0 {
207 b.lastByte = int(p[n-1])
208 b.lastRuneSize = -1
209 }
210 return n, b.readErr()
211 }
212
213
214 b.r = 0
215 b.w = 0
216 n, b.err = b.rd.Read(b.buf)
217 if n < 0 {
218 panic(errNegativeRead)
219 }
220 if n == 0 {
221 return 0, b.readErr()
222 }
223 b.w += n
224 }
225
226
227 n = copy(p, b.buf[b.r:b.w])
228 b.r += n
229 b.lastByte = int(b.buf[b.r-1])
230 b.lastRuneSize = -1
231 return n, nil
232 }
233
234
235
236 func (b *Reader) ReadByte() (byte, error) {
237 b.lastRuneSize = -1
238 for b.r == b.w {
239 if b.err != nil {
240 return 0, b.readErr()
241 }
242 b.fill()
243 }
244 c := b.buf[b.r]
245 b.r++
246 b.lastByte = int(c)
247 return c, nil
248 }
249
250
251 func (b *Reader) UnreadByte() error {
252 if b.lastByte < 0 || b.r == 0 && b.w > 0 {
253 return ErrInvalidUnreadByte
254 }
255
256 if b.r > 0 {
257 b.r--
258 } else {
259
260 b.w = 1
261 }
262 b.buf[b.r] = byte(b.lastByte)
263 b.lastByte = -1
264 b.lastRuneSize = -1
265 return nil
266 }
267
268
269
270
271 func (b *Reader) ReadRune() (r rune, size int, err error) {
272 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) {
273 b.fill()
274 }
275 b.lastRuneSize = -1
276 if b.r == b.w {
277 return 0, 0, b.readErr()
278 }
279 r, size = rune(b.buf[b.r]), 1
280 if r >= utf8.RuneSelf {
281 r, size = utf8.DecodeRune(b.buf[b.r:b.w])
282 }
283 b.r += size
284 b.lastByte = int(b.buf[b.r-1])
285 b.lastRuneSize = size
286 return r, size, nil
287 }
288
289
290
291
292
293 func (b *Reader) UnreadRune() error {
294 if b.lastRuneSize < 0 || b.r < b.lastRuneSize {
295 return ErrInvalidUnreadRune
296 }
297 b.r -= b.lastRuneSize
298 b.lastByte = -1
299 b.lastRuneSize = -1
300 return nil
301 }
302
303
304 func (b *Reader) Buffered() int { return b.w - b.r }
305
306
307
308
309
310
311
312
313
314
315
316 func (b *Reader) ReadSlice(delim byte) (line []byte, err error) {
317 for {
318
319 if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 {
320 line = b.buf[b.r : b.r+i+1]
321 b.r += i + 1
322 break
323 }
324
325
326 if b.err != nil {
327 line = b.buf[b.r:b.w]
328 b.r = b.w
329 err = b.readErr()
330 break
331 }
332
333
334 if b.Buffered() >= len(b.buf) {
335 b.r = b.w
336 line = b.buf
337 err = ErrBufferFull
338 break
339 }
340
341 b.fill()
342 }
343
344
345 if i := len(line) - 1; i >= 0 {
346 b.lastByte = int(line[i])
347 b.lastRuneSize = -1
348 }
349
350 return
351 }
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369 func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) {
370 line, err = b.ReadSlice('\n')
371 if err == ErrBufferFull {
372
373 if len(line) > 0 && line[len(line)-1] == '\r' {
374
375
376 if b.r == 0 {
377
378 panic("bufio: tried to rewind past start of buffer")
379 }
380 b.r--
381 line = line[:len(line)-1]
382 }
383 return line, true, nil
384 }
385
386 if len(line) == 0 {
387 if err != nil {
388 line = nil
389 }
390 return
391 }
392 err = nil
393
394 if line[len(line)-1] == '\n' {
395 drop := 1
396 if len(line) > 1 && line[len(line)-2] == '\r' {
397 drop = 2
398 }
399 line = line[:len(line)-drop]
400 }
401 return
402 }
403
404
405
406
407
408
409
410
411 func (b *Reader) ReadBytes(delim byte) ([]byte, error) {
412
413
414 var frag []byte
415 var full [][]byte
416 var err error
417 for {
418 var e error
419 frag, e = b.ReadSlice(delim)
420 if e == nil {
421 break
422 }
423 if e != ErrBufferFull {
424 err = e
425 break
426 }
427
428
429 buf := make([]byte, len(frag))
430 copy(buf, frag)
431 full = append(full, buf)
432 }
433
434
435 n := 0
436 for i := range full {
437 n += len(full[i])
438 }
439 n += len(frag)
440
441
442 buf := make([]byte, n)
443 n = 0
444 for i := range full {
445 n += copy(buf[n:], full[i])
446 }
447 copy(buf[n:], frag)
448 return buf, err
449 }
450
451
452
453
454
455
456
457
458 func (b *Reader) ReadString(delim byte) (string, error) {
459 bytes, err := b.ReadBytes(delim)
460 return string(bytes), err
461 }
462
463
464
465 func (b *Reader) WriteTo(w io.Writer) (n int64, err error) {
466 n, err = b.writeBuf(w)
467 if err != nil {
468 return
469 }
470
471 if r, ok := b.rd.(io.WriterTo); ok {
472 m, err := r.WriteTo(w)
473 n += m
474 return n, err
475 }
476
477 if w, ok := w.(io.ReaderFrom); ok {
478 m, err := w.ReadFrom(b.rd)
479 n += m
480 return n, err
481 }
482
483 if b.w-b.r < len(b.buf) {
484 b.fill()
485 }
486
487 for b.r < b.w {
488
489 m, err := b.writeBuf(w)
490 n += m
491 if err != nil {
492 return n, err
493 }
494 b.fill()
495 }
496
497 if b.err == io.EOF {
498 b.err = nil
499 }
500
501 return n, b.readErr()
502 }
503
504 var errNegativeWrite = errors.New("bufio: writer returned negative count from Write")
505
506
507 func (b *Reader) writeBuf(w io.Writer) (int64, error) {
508 n, err := w.Write(b.buf[b.r:b.w])
509 if n < 0 {
510 panic(errNegativeWrite)
511 }
512 b.r += n
513 return int64(n), err
514 }
515
516
517
518
519
520
521
522
523
524 type Writer struct {
525 err error
526 buf []byte
527 n int
528 wr io.Writer
529 }
530
531
532
533
534 func NewWriterSize(w io.Writer, size int) *Writer {
535
536 b, ok := w.(*Writer)
537 if ok && len(b.buf) >= size {
538 return b
539 }
540 if size <= 0 {
541 size = defaultBufSize
542 }
543 return &Writer{
544 buf: make([]byte, size),
545 wr: w,
546 }
547 }
548
549
550 func NewWriter(w io.Writer) *Writer {
551 return NewWriterSize(w, defaultBufSize)
552 }
553
554
555 func (b *Writer) Size() int { return len(b.buf) }
556
557
558
559 func (b *Writer) Reset(w io.Writer) {
560 b.err = nil
561 b.n = 0
562 b.wr = w
563 }
564
565
566 func (b *Writer) Flush() error {
567 if b.err != nil {
568 return b.err
569 }
570 if b.n == 0 {
571 return nil
572 }
573 n, err := b.wr.Write(b.buf[0:b.n])
574 if n < b.n && err == nil {
575 err = io.ErrShortWrite
576 }
577 if err != nil {
578 if n > 0 && n < b.n {
579 copy(b.buf[0:b.n-n], b.buf[n:b.n])
580 }
581 b.n -= n
582 b.err = err
583 return err
584 }
585 b.n = 0
586 return nil
587 }
588
589
590 func (b *Writer) Available() int { return len(b.buf) - b.n }
591
592
593 func (b *Writer) Buffered() int { return b.n }
594
595
596
597
598
599 func (b *Writer) Write(p []byte) (nn int, err error) {
600 for len(p) > b.Available() && b.err == nil {
601 var n int
602 if b.Buffered() == 0 {
603
604
605 n, b.err = b.wr.Write(p)
606 } else {
607 n = copy(b.buf[b.n:], p)
608 b.n += n
609 b.Flush()
610 }
611 nn += n
612 p = p[n:]
613 }
614 if b.err != nil {
615 return nn, b.err
616 }
617 n := copy(b.buf[b.n:], p)
618 b.n += n
619 nn += n
620 return nn, nil
621 }
622
623
624 func (b *Writer) WriteByte(c byte) error {
625 if b.err != nil {
626 return b.err
627 }
628 if b.Available() <= 0 && b.Flush() != nil {
629 return b.err
630 }
631 b.buf[b.n] = c
632 b.n++
633 return nil
634 }
635
636
637
638 func (b *Writer) WriteRune(r rune) (size int, err error) {
639 if r < utf8.RuneSelf {
640 err = b.WriteByte(byte(r))
641 if err != nil {
642 return 0, err
643 }
644 return 1, nil
645 }
646 if b.err != nil {
647 return 0, b.err
648 }
649 n := b.Available()
650 if n < utf8.UTFMax {
651 if b.Flush(); b.err != nil {
652 return 0, b.err
653 }
654 n = b.Available()
655 if n < utf8.UTFMax {
656
657 return b.WriteString(string(r))
658 }
659 }
660 size = utf8.EncodeRune(b.buf[b.n:], r)
661 b.n += size
662 return size, nil
663 }
664
665
666
667
668
669 func (b *Writer) WriteString(s string) (int, error) {
670 nn := 0
671 for len(s) > b.Available() && b.err == nil {
672 n := copy(b.buf[b.n:], s)
673 b.n += n
674 nn += n
675 s = s[n:]
676 b.Flush()
677 }
678 if b.err != nil {
679 return nn, b.err
680 }
681 n := copy(b.buf[b.n:], s)
682 b.n += n
683 nn += n
684 return nn, nil
685 }
686
687
688 func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) {
689 if b.Buffered() == 0 {
690 if w, ok := b.wr.(io.ReaderFrom); ok {
691 return w.ReadFrom(r)
692 }
693 }
694 var m int
695 for {
696 if b.Available() == 0 {
697 if err1 := b.Flush(); err1 != nil {
698 return n, err1
699 }
700 }
701 nr := 0
702 for nr < maxConsecutiveEmptyReads {
703 m, err = r.Read(b.buf[b.n:])
704 if m != 0 || err != nil {
705 break
706 }
707 nr++
708 }
709 if nr == maxConsecutiveEmptyReads {
710 return n, io.ErrNoProgress
711 }
712 b.n += m
713 n += int64(m)
714 if err != nil {
715 break
716 }
717 }
718 if err == io.EOF {
719
720 if b.Available() == 0 {
721 err = b.Flush()
722 } else {
723 err = nil
724 }
725 }
726 return n, err
727 }
728
729
730
731
732
733 type ReadWriter struct {
734 *Reader
735 *Writer
736 }
737
738
739 func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
740 return &ReadWriter{r, w}
741 }
742
View as plain text