| // Copyright 2009 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| // This package implements buffered I/O. It wraps an io.Reader or io.Writer | |
| // object, creating another object (Reader or Writer) that also implements | |
| // the interface but provides buffering and some help for textual I/O. | |
| package bufio | |
| import ( | |
| "io"; | |
| "os"; | |
| "strconv"; | |
| "utf8"; | |
| ) | |
| // TODO: | |
| // - maybe define an interface | |
| // - Reader: ReadRune, UnreadRune ? | |
| // could make ReadRune generic if we dropped UnreadRune | |
| // - buffered output | |
| const ( | |
| defaultBufSize = 4096 | |
| ) | |
| // Errors introduced by this package. | |
| type Error struct { | |
| os.ErrorString; | |
| } | |
| var ( | |
| ErrInvalidUnreadByte os.Error = &Error{"bufio: invalid use of UnreadByte"}; | |
| ErrBufferFull os.Error = &Error{"bufio: buffer full"}; | |
| errInternal os.Error = &Error{"bufio: internal error"}; | |
| ) | |
| // BufSizeError is the error representing an invalid buffer size. | |
| type BufSizeError int | |
| func (b BufSizeError) String() string { | |
| return "bufio: bad buffer size " + strconv.Itoa(int(b)); | |
| } | |
| func copySlice(dst []byte, src []byte) { | |
| for i := 0; i < len(dst); i++ { | |
| dst[i] = src[i] | |
| } | |
| } | |
| // Buffered input. | |
| // Reader implements buffering for an io.Reader object. | |
| type Reader struct { | |
| buf []byte; | |
| rd io.Reader; | |
| r, w int; | |
| err os.Error; | |
| lastbyte int; | |
| } | |
| // NewReaderSize creates a new Reader whose buffer has the specified size, | |
| // which must be greater than zero. If the argument io.Reader is already a | |
| // Reader with large enough size, it returns the underlying Reader. | |
| // It returns the Reader and any error. | |
| func NewReaderSize(rd io.Reader, size int) (*Reader, os.Error) { | |
| if size <= 0 { | |
| return nil, BufSizeError(size) | |
| } | |
| // Is it already a Reader? | |
| b, ok := rd.(*Reader); | |
| if ok && len(b.buf) >= size { | |
| return b, nil | |
| } | |
| b = new(Reader); | |
| b.buf = make([]byte, size); | |
| b.rd = rd; | |
| b.lastbyte = -1; | |
| return b, nil | |
| } | |
| // NewReader returns a new Reader whose buffer has the default size. | |
| func NewReader(rd io.Reader) *Reader { | |
| b, err := NewReaderSize(rd, defaultBufSize); | |
| if err != nil { | |
| // cannot happen - defaultBufSize is a valid size | |
| panic("bufio: NewReader: ", err.String()); | |
| } | |
| return b; | |
| } | |
| //.fill reads a new chunk into the buffer. | |
| func (b *Reader) fill() os.Error { | |
| if b.err != nil { | |
| return b.err | |
| } | |
| // Slide existing data to beginning. | |
| if b.w > b.r { | |
| copySlice(b.buf[0:b.w-b.r], b.buf[b.r:b.w]); | |
| b.w -= b.r; | |
| } else { | |
| b.w = 0 | |
| } | |
| b.r = 0; | |
| // Read new data. | |
| n, e := b.rd.Read(b.buf[b.w:len(b.buf)]); | |
| if e != nil { | |
| b.err = e; | |
| return e | |
| } | |
| b.w += n; | |
| return nil | |
| } | |
| // Read reads data into p. | |
| // It returns the number of bytes read into p. | |
| // If nn < len(p), also returns an error explaining | |
| // why the read is short. At EOF, the count will be | |
| // zero and err will be os.EOF. | |
| func (b *Reader) Read(p []byte) (nn int, err os.Error) { | |
| nn = 0; | |
| for len(p) > 0 { | |
| n := len(p); | |
| if b.w == b.r { | |
| if len(p) >= len(b.buf) { | |
| // Large read, empty buffer. | |
| // Read directly into p to avoid copy. | |
| n, b.err = b.rd.Read(p); | |
| if n > 0 { | |
| b.lastbyte = int(p[n-1]); | |
| } | |
| p = p[n:len(p)]; | |
| nn += n; | |
| if b.err != nil { | |
| return nn, b.err | |
| } | |
| continue; | |
| } | |
| b.fill(); | |
| if b.err != nil { | |
| return nn, b.err | |
| } | |
| } | |
| if n > b.w - b.r { | |
| n = b.w - b.r | |
| } | |
| copySlice(p[0:n], b.buf[b.r:b.r+n]); | |
| p = p[n:len(p)]; | |
| b.r += n; | |
| b.lastbyte = int(b.buf[b.r-1]); | |
| nn += n | |
| } | |
| return nn, nil | |
| } | |
| // ReadByte reads and returns a single byte. | |
| // If no byte is available, returns an error. | |
| func (b *Reader) ReadByte() (c byte, err os.Error) { | |
| if b.w == b.r { | |
| b.fill(); | |
| if b.err != nil { | |
| return 0, b.err | |
| } | |
| } | |
| c = b.buf[b.r]; | |
| b.r++; | |
| b.lastbyte = int(c); | |
| return c, nil | |
| } | |
| // UnreadByte unreads the last byte. Only the most recently read byte can be unread. | |
| func (b *Reader) UnreadByte() os.Error { | |
| if b.err != nil { | |
| return b.err | |
| } | |
| if b.r == b.w && b.lastbyte >= 0 { | |
| b.w = 1; | |
| b.r = 0; | |
| b.buf[0] = byte(b.lastbyte); | |
| b.lastbyte = -1; | |
| return nil; | |
| } | |
| if b.r <= 0 { | |
| return ErrInvalidUnreadByte | |
| } | |
| b.r--; | |
| b.lastbyte = -1; | |
| return nil | |
| } | |
| // ReadRune reads a single UTF-8 encoded Unicode character and returns the | |
| // rune and its size in bytes. | |
| func (b *Reader) ReadRune() (rune int, size int, err os.Error) { | |
| for b.r + utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r:b.w]) { | |
| n := b.w - b.r; | |
| b.fill(); | |
| if b.err != nil { | |
| return 0, 0, b.err | |
| } | |
| if b.w - b.r == n { | |
| // no bytes read | |
| break; | |
| } | |
| } | |
| rune, size = int(b.buf[b.r]), 1; | |
| if rune >= 0x80 { | |
| rune, size = utf8.DecodeRune(b.buf[b.r:b.w]); | |
| } | |
| b.r += size; | |
| b.lastbyte = int(b.buf[b.r-1]); | |
| return rune, size, nil | |
| } | |
| // Helper function: look for byte c in array p, | |
| // returning its index or -1. | |
| func findByte(p []byte, c byte) int { | |
| for i := 0; i < len(p); i++ { | |
| if p[i] == c { | |
| return i | |
| } | |
| } | |
| return -1 | |
| } | |
| // Buffered returns the number of bytes that can be read from the current buffer. | |
| func (b *Reader) Buffered() int { | |
| return b.w - b.r; | |
| } | |
| // ReadLineSlice reads until the first occurrence of delim in the input, | |
| // returning a slice pointing at the bytes in the buffer. | |
| // The bytes stop being valid at the next read call. | |
| // Fails if the line doesn't fit in the buffer. | |
| // For internal or advanced use only; most uses should | |
| // call ReadLineString or ReadLineBytes instead. | |
| func (b *Reader) ReadLineSlice(delim byte) (line []byte, err os.Error) { | |
| if b.err != nil { | |
| return nil, b.err | |
| } | |
| // Look in buffer. | |
| if i := findByte(b.buf[b.r:b.w], delim); i >= 0 { | |
| line1 := b.buf[b.r:b.r+i+1]; | |
| b.r += i+1; | |
| return line1, nil | |
| } | |
| // Read more into buffer, until buffer fills or we find delim. | |
| for { | |
| n := b.Buffered(); | |
| b.fill(); | |
| if b.err != nil { | |
| line := b.buf[b.r:b.w]; | |
| b.r = b.w; | |
| return line, b.err | |
| } | |
| // Search new part of buffer | |
| if i := findByte(b.buf[n:b.w], delim); i >= 0 { | |
| line := b.buf[0:n+i+1]; | |
| b.r = n+i+1; | |
| return line, nil | |
| } | |
| // Buffer is full? | |
| if b.Buffered() >= len(b.buf) { | |
| return nil, ErrBufferFull | |
| } | |
| } | |
| panic("not reached"); | |
| } | |
| // ReadLineBytes reads until the first occurrence of delim in the input, | |
| // returning a new byte array containing the line. | |
| // If an error happens, returns the data (without a delimiter) | |
| // and the error. (It can't leave the data in the buffer because | |
| // it might have read more than the buffer size.) | |
| func (b *Reader) ReadLineBytes(delim byte) (line []byte, err os.Error) { | |
| if b.err != nil { | |
| return nil, b.err | |
| } | |
| // Use ReadLineSlice to look for array, | |
| // accumulating full buffers. | |
| var frag []byte; | |
| var full [][]byte; | |
| nfull := 0; | |
| err = nil; | |
| for { | |
| var e os.Error; | |
| frag, e = b.ReadLineSlice(delim); | |
| if e == nil { // got final fragment | |
| break | |
| } | |
| if e != ErrBufferFull { // unexpected error | |
| err = e; | |
| break | |
| } | |
| // Read bytes out of buffer. | |
| buf := make([]byte, b.Buffered()); | |
| var n int; | |
| n, e = b.Read(buf); | |
| if e != nil { | |
| frag = buf[0:n]; | |
| err = e; | |
| break | |
| } | |
| if n != len(buf) { | |
| frag = buf[0:n]; | |
| err = errInternal; | |
| break | |
| } | |
| // Grow list if needed. | |
| if full == nil { | |
| full = make([][]byte, 16); | |
| } else if nfull >= len(full) { | |
| newfull := make([][]byte, len(full)*2); | |
| for i := 0; i < len(full); i++ { | |
| newfull[i] = full[i]; | |
| } | |
| full = newfull | |
| } | |
| // Save buffer | |
| full[nfull] = buf; | |
| nfull++; | |
| } | |
| // Allocate new buffer to hold the full pieces and the fragment. | |
| n := 0; | |
| for i := 0; i < nfull; i++ { | |
| n += len(full[i]) | |
| } | |
| n += len(frag); | |
| // Copy full pieces and fragment in. | |
| buf := make([]byte, n); | |
| n = 0; | |
| for i := 0; i < nfull; i++ { | |
| copySlice(buf[n:n+len(full[i])], full[i]); | |
| n += len(full[i]) | |
| } | |
| copySlice(buf[n:n+len(frag)], frag); | |
| return buf, err | |
| } | |
| // ReadLineString reads until the first occurrence of delim in the input, | |
| // returning a new string containing the line. | |
| // If savedelim, keep delim in the result; otherwise drop it. | |
| func (b *Reader) ReadLineString(delim byte, savedelim bool) (line string, err os.Error) { | |
| bytes, e := b.ReadLineBytes(delim); | |
| if e != nil { | |
| return string(bytes), e | |
| } | |
| if !savedelim { | |
| bytes = bytes[0:len(bytes)-1] | |
| } | |
| return string(bytes), nil | |
| } | |
| // buffered output | |
| // Writer implements buffering for an io.Writer object. | |
| type Writer struct { | |
| err os.Error; | |
| buf []byte; | |
| n int; | |
| wr io.Writer; | |
| } | |
| // NewWriterSize creates a new Writer whose buffer has the specified size, | |
| // which must be greater than zero. If the argument io.Writer is already a | |
| // Writer with large enough size, it returns the underlying Writer. | |
| // It returns the Writer and any error. | |
| func NewWriterSize(wr io.Writer, size int) (*Writer, os.Error) { | |
| if size <= 0 { | |
| return nil, BufSizeError(size) | |
| } | |
| // Is it already a Writer? | |
| b, ok := wr.(*Writer); | |
| if ok && len(b.buf) >= size { | |
| return b, nil | |
| } | |
| b = new(Writer); | |
| b.buf = make([]byte, size); | |
| b.wr = wr; | |
| return b, nil | |
| } | |
| // NewWriter returns a new Writer whose buffer has the default size. | |
| func NewWriter(wr io.Writer) *Writer { | |
| b, err := NewWriterSize(wr, defaultBufSize); | |
| if err != nil { | |
| // cannot happen - defaultBufSize is valid size | |
| panic("bufio: NewWriter: ", err.String()); | |
| } | |
| return b; | |
| } | |
| // Flush writes any buffered data to the underlying io.Writer. | |
| func (b *Writer) Flush() os.Error { | |
| if b.err != nil { | |
| return b.err | |
| } | |
| n, e := b.wr.Write(b.buf[0:b.n]); | |
| if n < b.n && e == nil { | |
| e = io.ErrShortWrite; | |
| } | |
| if e != nil { | |
| if n > 0 && n < b.n { | |
| copySlice(b.buf[0:b.n-n], b.buf[n:b.n]) | |
| } | |
| b.n -= n; | |
| b.err = e; | |
| return e | |
| } | |
| b.n = 0; | |
| return nil | |
| } | |
| // Available returns how many bytes are unused in the buffer. | |
| func (b *Writer) Available() int { | |
| return len(b.buf) - b.n | |
| } | |
| // Buffered returns the number of bytes that have been written into the current buffer. | |
| func (b *Writer) Buffered() int { | |
| return b.n | |
| } | |
| // Write writes the contents of p into the buffer. | |
| // It returns the number of bytes written. | |
| // If nn < len(p), also returns an error explaining | |
| // why the write is short. | |
| func (b *Writer) Write(p []byte) (nn int, err os.Error) { | |
| if b.err != nil { | |
| return 0, b.err | |
| } | |
| nn = 0; | |
| for len(p) > 0 { | |
| n := b.Available(); | |
| if n <= 0 { | |
| if b.Flush(); b.err != nil { | |
| break | |
| } | |
| n = b.Available() | |
| } | |
| if b.Available() == 0 && len(p) >= len(b.buf) { | |
| // Large write, empty buffer. | |
| // Write directly from p to avoid copy. | |
| n, b.err = b.wr.Write(p); | |
| nn += n; | |
| p = p[n:len(p)]; | |
| if b.err != nil { | |
| break; | |
| } | |
| continue; | |
| } | |
| if n > len(p) { | |
| n = len(p) | |
| } | |
| copySlice(b.buf[b.n:b.n+n], p[0:n]); | |
| b.n += n; | |
| nn += n; | |
| p = p[n:len(p)] | |
| } | |
| return nn, b.err | |
| } | |
| // WriteByte writes a single byte. | |
| func (b *Writer) WriteByte(c byte) os.Error { | |
| if b.err != nil { | |
| return b.err | |
| } | |
| if b.Available() <= 0 && b.Flush() != nil { | |
| return b.err | |
| } | |
| b.buf[b.n] = c; | |
| b.n++; | |
| return nil | |
| } | |
| // buffered input and output | |
| // ReadWriter stores pointers to a Reader and a Writer. | |
| // It implements io.ReadWriter. | |
| type ReadWriter struct { | |
| *Reader; | |
| *Writer; | |
| } | |
| // NewReadWriter allocates a new ReadWriter that dispatches to r and w. | |
| func NewReadWriter(r *Reader, w *Writer) *ReadWriter { | |
| return &ReadWriter{r, w} | |
| } | |