github.com/xushiwei/go@v0.0.0-20130601165731-2b9d83f45bc9/src/pkg/bufio/bufio.go (about) 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 34 r, w int 35 err error 36 lastByte int 37 lastRuneSize int 38 } 39 40 const minReadBufferSize = 16 41 42 // NewReaderSize returns a new Reader whose buffer has at least the specified 43 // size. If the argument io.Reader is already a Reader with large enough 44 // size, it returns the underlying Reader. 45 func NewReaderSize(rd io.Reader, size int) *Reader { 46 // Is it already a Reader? 47 b, ok := rd.(*Reader) 48 if ok && len(b.buf) >= size { 49 return b 50 } 51 if size < minReadBufferSize { 52 size = minReadBufferSize 53 } 54 return &Reader{ 55 buf: make([]byte, size), 56 rd: rd, 57 lastByte: -1, 58 lastRuneSize: -1, 59 } 60 } 61 62 // NewReader returns a new Reader whose buffer has the default size. 63 func NewReader(rd io.Reader) *Reader { 64 return NewReaderSize(rd, defaultBufSize) 65 } 66 67 var errNegativeRead = errors.New("bufio: reader returned negative count from Read") 68 69 // fill reads a new chunk into the buffer. 70 func (b *Reader) fill() { 71 // Slide existing data to beginning. 72 if b.r > 0 { 73 copy(b.buf, b.buf[b.r:b.w]) 74 b.w -= b.r 75 b.r = 0 76 } 77 78 // Read new data. 79 n, err := b.rd.Read(b.buf[b.w:]) 80 if n < 0 { 81 panic(errNegativeRead) 82 } 83 b.w += n 84 if err != nil { 85 b.err = err 86 } 87 } 88 89 func (b *Reader) readErr() error { 90 err := b.err 91 b.err = nil 92 return err 93 } 94 95 // Peek returns the next n bytes without advancing the reader. The bytes stop 96 // being valid at the next read call. If Peek returns fewer than n bytes, it 97 // also returns an error explaining why the read is short. The error is 98 // ErrBufferFull if n is larger than b's buffer size. 99 func (b *Reader) Peek(n int) ([]byte, error) { 100 if n < 0 { 101 return nil, ErrNegativeCount 102 } 103 if n > len(b.buf) { 104 return nil, ErrBufferFull 105 } 106 for b.w-b.r < n && b.err == nil { 107 b.fill() 108 } 109 m := b.w - b.r 110 if m > n { 111 m = n 112 } 113 var err error 114 if m < n { 115 err = b.readErr() 116 if err == nil { 117 err = ErrBufferFull 118 } 119 } 120 return b.buf[b.r : b.r+m], err 121 } 122 123 // Read reads data into p. 124 // It returns the number of bytes read into p. 125 // It calls Read at most once on the underlying Reader, 126 // hence n may be less than len(p). 127 // At EOF, the count will be zero and err will be io.EOF. 128 func (b *Reader) Read(p []byte) (n int, err error) { 129 n = len(p) 130 if n == 0 { 131 return 0, b.readErr() 132 } 133 if b.w == b.r { 134 if b.err != nil { 135 return 0, b.readErr() 136 } 137 if len(p) >= len(b.buf) { 138 // Large read, empty buffer. 139 // Read directly into p to avoid copy. 140 n, b.err = b.rd.Read(p) 141 if n > 0 { 142 b.lastByte = int(p[n-1]) 143 b.lastRuneSize = -1 144 } 145 return n, b.readErr() 146 } 147 b.fill() 148 if b.w == b.r { 149 return 0, b.readErr() 150 } 151 } 152 153 if n > b.w-b.r { 154 n = b.w - b.r 155 } 156 copy(p[0:n], b.buf[b.r:]) 157 b.r += n 158 b.lastByte = int(b.buf[b.r-1]) 159 b.lastRuneSize = -1 160 return n, nil 161 } 162 163 // ReadByte reads and returns a single byte. 164 // If no byte is available, returns an error. 165 func (b *Reader) ReadByte() (c byte, err error) { 166 b.lastRuneSize = -1 167 for b.w == b.r { 168 if b.err != nil { 169 return 0, b.readErr() 170 } 171 b.fill() 172 } 173 c = b.buf[b.r] 174 b.r++ 175 b.lastByte = int(c) 176 return c, nil 177 } 178 179 // UnreadByte unreads the last byte. Only the most recently read byte can be unread. 180 func (b *Reader) UnreadByte() error { 181 b.lastRuneSize = -1 182 if b.r == b.w && b.lastByte >= 0 { 183 b.w = 1 184 b.r = 0 185 b.buf[0] = byte(b.lastByte) 186 b.lastByte = -1 187 return nil 188 } 189 if b.r <= 0 { 190 return ErrInvalidUnreadByte 191 } 192 b.r-- 193 b.lastByte = -1 194 return nil 195 } 196 197 // ReadRune reads a single UTF-8 encoded Unicode character and returns the 198 // rune and its size in bytes. If the encoded rune is invalid, it consumes one byte 199 // and returns unicode.ReplacementChar (U+FFFD) with a size of 1. 200 func (b *Reader) ReadRune() (r rune, size int, err error) { 201 for b.r+utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r:b.w]) && b.err == nil { 202 b.fill() 203 } 204 b.lastRuneSize = -1 205 if b.r == b.w { 206 return 0, 0, b.readErr() 207 } 208 r, size = rune(b.buf[b.r]), 1 209 if r >= 0x80 { 210 r, size = utf8.DecodeRune(b.buf[b.r:b.w]) 211 } 212 b.r += size 213 b.lastByte = int(b.buf[b.r-1]) 214 b.lastRuneSize = size 215 return r, size, nil 216 } 217 218 // UnreadRune unreads the last rune. If the most recent read operation on 219 // the buffer was not a ReadRune, UnreadRune returns an error. (In this 220 // regard it is stricter than UnreadByte, which will unread the last byte 221 // from any read operation.) 222 func (b *Reader) UnreadRune() error { 223 if b.lastRuneSize < 0 || b.r == 0 { 224 return ErrInvalidUnreadRune 225 } 226 b.r -= b.lastRuneSize 227 b.lastByte = -1 228 b.lastRuneSize = -1 229 return nil 230 } 231 232 // Buffered returns the number of bytes that can be read from the current buffer. 233 func (b *Reader) Buffered() int { return b.w - b.r } 234 235 // ReadSlice reads until the first occurrence of delim in the input, 236 // returning a slice pointing at the bytes in the buffer. 237 // The bytes stop being valid at the next read call. 238 // If ReadSlice encounters an error before finding a delimiter, 239 // it returns all the data in the buffer and the error itself (often io.EOF). 240 // ReadSlice fails with error ErrBufferFull if the buffer fills without a delim. 241 // Because the data returned from ReadSlice will be overwritten 242 // by the next I/O operation, most clients should use 243 // ReadBytes or ReadString instead. 244 // ReadSlice returns err != nil if and only if line does not end in delim. 245 func (b *Reader) ReadSlice(delim byte) (line []byte, err error) { 246 // Look in buffer. 247 if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 { 248 line1 := b.buf[b.r : b.r+i+1] 249 b.r += i + 1 250 return line1, nil 251 } 252 253 // Read more into buffer, until buffer fills or we find delim. 254 for { 255 if b.err != nil { 256 line := b.buf[b.r:b.w] 257 b.r = b.w 258 return line, b.readErr() 259 } 260 261 n := b.Buffered() 262 b.fill() 263 264 // Search new part of buffer 265 if i := bytes.IndexByte(b.buf[n:b.w], delim); i >= 0 { 266 line := b.buf[0 : n+i+1] 267 b.r = n + i + 1 268 return line, nil 269 } 270 271 // Buffer is full? 272 if b.Buffered() >= len(b.buf) { 273 b.r = b.w 274 return b.buf, ErrBufferFull 275 } 276 } 277 } 278 279 // ReadLine is a low-level line-reading primitive. Most callers should use 280 // ReadBytes('\n') or ReadString('\n') instead or use a Scanner. 281 // 282 // ReadLine tries to return a single line, not including the end-of-line bytes. 283 // If the line was too long for the buffer then isPrefix is set and the 284 // beginning of the line is returned. The rest of the line will be returned 285 // from future calls. isPrefix will be false when returning the last fragment 286 // of the line. The returned buffer is only valid until the next call to 287 // ReadLine. ReadLine either returns a non-nil line or it returns an error, 288 // never both. 289 // 290 // The text returned from ReadLine does not include the line end ("\r\n" or "\n"). 291 // No indication or error is given if the input ends without a final line end. 292 func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) { 293 line, err = b.ReadSlice('\n') 294 if err == ErrBufferFull { 295 // Handle the case where "\r\n" straddles the buffer. 296 if len(line) > 0 && line[len(line)-1] == '\r' { 297 // Put the '\r' back on buf and drop it from line. 298 // Let the next call to ReadLine check for "\r\n". 299 if b.r == 0 { 300 // should be unreachable 301 panic("bufio: tried to rewind past start of buffer") 302 } 303 b.r-- 304 line = line[:len(line)-1] 305 } 306 return line, true, nil 307 } 308 309 if len(line) == 0 { 310 if err != nil { 311 line = nil 312 } 313 return 314 } 315 err = nil 316 317 if line[len(line)-1] == '\n' { 318 drop := 1 319 if len(line) > 1 && line[len(line)-2] == '\r' { 320 drop = 2 321 } 322 line = line[:len(line)-drop] 323 } 324 return 325 } 326 327 // ReadBytes reads until the first occurrence of delim in the input, 328 // returning a slice containing the data up to and including the delimiter. 329 // If ReadBytes encounters an error before finding a delimiter, 330 // it returns the data read before the error and the error itself (often io.EOF). 331 // ReadBytes returns err != nil if and only if the returned data does not end in 332 // delim. 333 // For simple uses, a Scanner may be more convenient. 334 func (b *Reader) ReadBytes(delim byte) (line []byte, err error) { 335 // Use ReadSlice to look for array, 336 // accumulating full buffers. 337 var frag []byte 338 var full [][]byte 339 err = nil 340 341 for { 342 var e error 343 frag, e = b.ReadSlice(delim) 344 if e == nil { // got final fragment 345 break 346 } 347 if e != ErrBufferFull { // unexpected error 348 err = e 349 break 350 } 351 352 // Make a copy of the buffer. 353 buf := make([]byte, len(frag)) 354 copy(buf, frag) 355 full = append(full, buf) 356 } 357 358 // Allocate new buffer to hold the full pieces and the fragment. 359 n := 0 360 for i := range full { 361 n += len(full[i]) 362 } 363 n += len(frag) 364 365 // Copy full pieces and fragment in. 366 buf := make([]byte, n) 367 n = 0 368 for i := range full { 369 n += copy(buf[n:], full[i]) 370 } 371 copy(buf[n:], frag) 372 return buf, err 373 } 374 375 // ReadString reads until the first occurrence of delim in the input, 376 // returning a string containing the data up to and including the delimiter. 377 // If ReadString encounters an error before finding a delimiter, 378 // it returns the data read before the error and the error itself (often io.EOF). 379 // ReadString returns err != nil if and only if the returned data does not end in 380 // delim. 381 // For simple uses, a Scanner may be more convenient. 382 func (b *Reader) ReadString(delim byte) (line string, err error) { 383 bytes, err := b.ReadBytes(delim) 384 return string(bytes), err 385 } 386 387 // WriteTo implements io.WriterTo. 388 func (b *Reader) WriteTo(w io.Writer) (n int64, err error) { 389 n, err = b.writeBuf(w) 390 if err != nil { 391 return 392 } 393 394 if r, ok := b.rd.(io.WriterTo); ok { 395 m, err := r.WriteTo(w) 396 n += m 397 return n, err 398 } 399 400 for b.fill(); b.r < b.w; b.fill() { 401 m, err := b.writeBuf(w) 402 n += m 403 if err != nil { 404 return n, err 405 } 406 } 407 408 if b.err == io.EOF { 409 b.err = nil 410 } 411 412 return n, b.readErr() 413 } 414 415 // writeBuf writes the Reader's buffer to the writer. 416 func (b *Reader) writeBuf(w io.Writer) (int64, error) { 417 n, err := w.Write(b.buf[b.r:b.w]) 418 b.r += n 419 return int64(n), err 420 } 421 422 // buffered output 423 424 // Writer implements buffering for an io.Writer object. 425 // If an error occurs writing to a Writer, no more data will be 426 // accepted and all subsequent writes will return the error. 427 type Writer struct { 428 err error 429 buf []byte 430 n int 431 wr io.Writer 432 } 433 434 // NewWriterSize returns a new Writer whose buffer has at least the specified 435 // size. If the argument io.Writer is already a Writer with large enough 436 // size, it returns the underlying Writer. 437 func NewWriterSize(wr io.Writer, size int) *Writer { 438 // Is it already a Writer? 439 b, ok := wr.(*Writer) 440 if ok && len(b.buf) >= size { 441 return b 442 } 443 if size <= 0 { 444 size = defaultBufSize 445 } 446 b = new(Writer) 447 b.buf = make([]byte, size) 448 b.wr = wr 449 return b 450 } 451 452 // NewWriter returns a new Writer whose buffer has the default size. 453 func NewWriter(wr io.Writer) *Writer { 454 return NewWriterSize(wr, defaultBufSize) 455 } 456 457 // Flush writes any buffered data to the underlying io.Writer. 458 func (b *Writer) Flush() error { 459 if b.err != nil { 460 return b.err 461 } 462 if b.n == 0 { 463 return nil 464 } 465 n, err := b.wr.Write(b.buf[0:b.n]) 466 if n < b.n && err == nil { 467 err = io.ErrShortWrite 468 } 469 if err != nil { 470 if n > 0 && n < b.n { 471 copy(b.buf[0:b.n-n], b.buf[n:b.n]) 472 } 473 b.n -= n 474 b.err = err 475 return err 476 } 477 b.n = 0 478 return nil 479 } 480 481 // Available returns how many bytes are unused in the buffer. 482 func (b *Writer) Available() int { return len(b.buf) - b.n } 483 484 // Buffered returns the number of bytes that have been written into the current buffer. 485 func (b *Writer) Buffered() int { return b.n } 486 487 // Write writes the contents of p into the buffer. 488 // It returns the number of bytes written. 489 // If nn < len(p), it also returns an error explaining 490 // why the write is short. 491 func (b *Writer) Write(p []byte) (nn int, err error) { 492 for len(p) > b.Available() && b.err == nil { 493 var n int 494 if b.Buffered() == 0 { 495 // Large write, empty buffer. 496 // Write directly from p to avoid copy. 497 n, b.err = b.wr.Write(p) 498 } else { 499 n = copy(b.buf[b.n:], p) 500 b.n += n 501 b.Flush() 502 } 503 nn += n 504 p = p[n:] 505 } 506 if b.err != nil { 507 return nn, b.err 508 } 509 n := copy(b.buf[b.n:], p) 510 b.n += n 511 nn += n 512 return nn, nil 513 } 514 515 // WriteByte writes a single byte. 516 func (b *Writer) WriteByte(c byte) error { 517 if b.err != nil { 518 return b.err 519 } 520 if b.Available() <= 0 && b.Flush() != nil { 521 return b.err 522 } 523 b.buf[b.n] = c 524 b.n++ 525 return nil 526 } 527 528 // WriteRune writes a single Unicode code point, returning 529 // the number of bytes written and any error. 530 func (b *Writer) WriteRune(r rune) (size int, err error) { 531 if r < utf8.RuneSelf { 532 err = b.WriteByte(byte(r)) 533 if err != nil { 534 return 0, err 535 } 536 return 1, nil 537 } 538 if b.err != nil { 539 return 0, b.err 540 } 541 n := b.Available() 542 if n < utf8.UTFMax { 543 if b.Flush(); b.err != nil { 544 return 0, b.err 545 } 546 n = b.Available() 547 if n < utf8.UTFMax { 548 // Can only happen if buffer is silly small. 549 return b.WriteString(string(r)) 550 } 551 } 552 size = utf8.EncodeRune(b.buf[b.n:], r) 553 b.n += size 554 return size, nil 555 } 556 557 // WriteString writes a string. 558 // It returns the number of bytes written. 559 // If the count is less than len(s), it also returns an error explaining 560 // why the write is short. 561 func (b *Writer) WriteString(s string) (int, error) { 562 nn := 0 563 for len(s) > b.Available() && b.err == nil { 564 n := copy(b.buf[b.n:], s) 565 b.n += n 566 nn += n 567 s = s[n:] 568 b.Flush() 569 } 570 if b.err != nil { 571 return nn, b.err 572 } 573 n := copy(b.buf[b.n:], s) 574 b.n += n 575 nn += n 576 return nn, nil 577 } 578 579 // ReadFrom implements io.ReaderFrom. 580 func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) { 581 if b.Buffered() == 0 { 582 if w, ok := b.wr.(io.ReaderFrom); ok { 583 return w.ReadFrom(r) 584 } 585 } 586 var m int 587 for { 588 m, err = r.Read(b.buf[b.n:]) 589 if m == 0 { 590 break 591 } 592 b.n += m 593 n += int64(m) 594 if b.Available() == 0 { 595 if err1 := b.Flush(); err1 != nil { 596 return n, err1 597 } 598 } 599 if err != nil { 600 break 601 } 602 } 603 if err == io.EOF { 604 err = nil 605 } 606 return n, err 607 } 608 609 // buffered input and output 610 611 // ReadWriter stores pointers to a Reader and a Writer. 612 // It implements io.ReadWriter. 613 type ReadWriter struct { 614 *Reader 615 *Writer 616 } 617 618 // NewReadWriter allocates a new ReadWriter that dispatches to r and w. 619 func NewReadWriter(r *Reader, w *Writer) *ReadWriter { 620 return &ReadWriter{r, w} 621 }