Add missing ECF_NOTHROW flags to internal.def

[official-gcc.git] / libgo / go / bufio / bufio.go

// 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.

// Package bufio 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 (
        "bytes"
        "errors"
        "io"
        "unicode/utf8"
)

const (
        defaultBufSize = 4096
)

var (
        ErrInvalidUnreadByte = errors.New("bufio: invalid use of UnreadByte")
        ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune")
        ErrBufferFull        = errors.New("bufio: buffer full")
        ErrNegativeCount     = errors.New("bufio: negative count")
)

// Buffered input.

// Reader implements buffering for an io.Reader object.
type Reader struct {
        buf          []byte
        rd           io.Reader // reader provided by the client
        r, w         int       // buf read and write positions
        err          error
        lastByte     int
        lastRuneSize int
}

const minReadBufferSize = 16
const maxConsecutiveEmptyReads = 100

// NewReaderSize returns a new Reader whose buffer has at least the specified
// size. If the argument io.Reader is already a Reader with large enough
// size, it returns the underlying Reader.
func NewReaderSize(rd io.Reader, size int) *Reader {
        // Is it already a Reader?
        b, ok := rd.(*Reader)
        if ok && len(b.buf) >= size {
                return b
        }
        if size < minReadBufferSize {
                size = minReadBufferSize
        }
        r := new(Reader)
        r.reset(make([]byte, size), rd)
        return r
}

// NewReader returns a new Reader whose buffer has the default size.
func NewReader(rd io.Reader) *Reader {
        return NewReaderSize(rd, defaultBufSize)
}

// Reset discards any buffered data, resets all state, and switches
// the buffered reader to read from r.
func (b *Reader) Reset(r io.Reader) {
        b.reset(b.buf, r)
}

func (b *Reader) reset(buf []byte, r io.Reader) {
        *b = Reader{
                buf:          buf,
                rd:           r,
                lastByte:     -1,
                lastRuneSize: -1,
        }
}

var errNegativeRead = errors.New("bufio: reader returned negative count from Read")

// fill reads a new chunk into the buffer.
func (b *Reader) fill() {
        // Slide existing data to beginning.
        if b.r > 0 {
                copy(b.buf, b.buf[b.r:b.w])
                b.w -= b.r
                b.r = 0
        }

        if b.w >= len(b.buf) {
                panic("bufio: tried to fill full buffer")
        }

        // Read new data: try a limited number of times.
        for i := maxConsecutiveEmptyReads; i > 0; i-- {
                n, err := b.rd.Read(b.buf[b.w:])
                if n < 0 {
                        panic(errNegativeRead)
                }
                b.w += n
                if err != nil {
                        b.err = err
                        return
                }
                if n > 0 {
                        return
                }
        }
        b.err = io.ErrNoProgress
}

func (b *Reader) readErr() error {
        err := b.err
        b.err = nil
        return err
}

// Peek returns the next n bytes without advancing the reader. The bytes stop
// being valid at the next read call. If Peek returns fewer than n bytes, it
// also returns an error explaining why the read is short. The error is
// ErrBufferFull if n is larger than b's buffer size.
func (b *Reader) Peek(n int) ([]byte, error) {
        if n < 0 {
                return nil, ErrNegativeCount
        }

        for b.w-b.r < n && b.w-b.r < len(b.buf) && b.err == nil {
                b.fill() // b.w-b.r < len(b.buf) => buffer is not full
        }

        if n > len(b.buf) {
                return b.buf[b.r:b.w], ErrBufferFull
        }

        // 0 <= n <= len(b.buf)
        var err error
        if avail := b.w - b.r; avail < n {
                // not enough data in buffer
                n = avail
                err = b.readErr()
                if err == nil {
                        err = ErrBufferFull
                }
        }
        return b.buf[b.r : b.r+n], err
}

// Discard skips the next n bytes, returning the number of bytes discarded.
//
// If Discard skips fewer than n bytes, it also returns an error.
// If 0 <= n <= b.Buffered(), Discard is guaranteed to succeed without
// reading from the underlying io.Reader.
func (b *Reader) Discard(n int) (discarded int, err error) {
        if n < 0 {
                return 0, ErrNegativeCount
        }
        if n == 0 {
                return
        }
        remain := n
        for {
                skip := b.Buffered()
                if skip == 0 {
                        b.fill()
                        skip = b.Buffered()
                }
                if skip > remain {
                        skip = remain
                }
                b.r += skip
                remain -= skip
                if remain == 0 {
                        return n, nil
                }
                if b.err != nil {
                        return n - remain, b.readErr()
                }
        }
}

// Read reads data into p.
// It returns the number of bytes read into p.
// The bytes are taken from at most one Read on the underlying Reader,
// hence n may be less than len(p).
// At EOF, the count will be zero and err will be io.EOF.
func (b *Reader) Read(p []byte) (n int, err error) {
        n = len(p)
        if n == 0 {
                return 0, b.readErr()
        }
        if b.r == b.w {
                if b.err != nil {
                        return 0, b.readErr()
                }
                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 {
                                panic(errNegativeRead)
                        }
                        if n > 0 {
                                b.lastByte = int(p[n-1])
                                b.lastRuneSize = -1
                        }
                        return n, b.readErr()
                }
                // One read.
                // Do not use b.fill, which will loop.
                b.r = 0
                b.w = 0
                n, b.err = b.rd.Read(b.buf)
                if n < 0 {
                        panic(errNegativeRead)
                }
                if n == 0 {
                        return 0, b.readErr()
                }
                b.w += n
        }

        // copy as much as we can
        n = copy(p, b.buf[b.r:b.w])
        b.r += n
        b.lastByte = int(b.buf[b.r-1])
        b.lastRuneSize = -1
        return n, nil
}

// ReadByte reads and returns a single byte.
// If no byte is available, returns an error.
func (b *Reader) ReadByte() (byte, error) {
        b.lastRuneSize = -1
        for b.r == b.w {
                if b.err != nil {
                        return 0, b.readErr()
                }
                b.fill() // buffer is empty
        }
        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() error {
        if b.lastByte < 0 || b.r == 0 && b.w > 0 {
                return ErrInvalidUnreadByte
        }
        // b.r > 0 || b.w == 0
        if b.r > 0 {
                b.r--
        } else {
                // b.r == 0 && b.w == 0
                b.w = 1
        }
        b.buf[b.r] = byte(b.lastByte)
        b.lastByte = -1
        b.lastRuneSize = -1
        return nil
}

// ReadRune reads a single UTF-8 encoded Unicode character and returns the
// rune and its size in bytes. If the encoded rune is invalid, it consumes one byte
// and returns unicode.ReplacementChar (U+FFFD) with a size of 1.
func (b *Reader) ReadRune() (r rune, size int, err error) {
        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) {
                b.fill() // b.w-b.r < len(buf) => buffer is not full
        }
        b.lastRuneSize = -1
        if b.r == b.w {
                return 0, 0, b.readErr()
        }
        r, size = rune(b.buf[b.r]), 1
        if r >= utf8.RuneSelf {
                r, size = utf8.DecodeRune(b.buf[b.r:b.w])
        }
        b.r += size
        b.lastByte = int(b.buf[b.r-1])
        b.lastRuneSize = size
        return r, size, nil
}

// UnreadRune unreads the last rune. If the most recent read operation on
// the buffer was not a ReadRune, UnreadRune returns an error.  (In this
// regard it is stricter than UnreadByte, which will unread the last byte
// from any read operation.)
func (b *Reader) UnreadRune() error {
        if b.lastRuneSize < 0 || b.r < b.lastRuneSize {
                return ErrInvalidUnreadRune
        }
        b.r -= b.lastRuneSize
        b.lastByte = -1
        b.lastRuneSize = -1
        return nil
}

// Buffered returns the number of bytes that can be read from the current buffer.
func (b *Reader) Buffered() int { return b.w - b.r }

// ReadSlice 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.
// If ReadSlice encounters an error before finding a delimiter,
// it returns all the data in the buffer and the error itself (often io.EOF).
// ReadSlice fails with error ErrBufferFull if the buffer fills without a delim.
// Because the data returned from ReadSlice will be overwritten
// by the next I/O operation, most clients should use
// ReadBytes or ReadString instead.
// ReadSlice returns err != nil if and only if line does not end in delim.
func (b *Reader) ReadSlice(delim byte) (line []byte, err error) {
        for {
                // Search buffer.
                if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 {
                        line = b.buf[b.r : b.r+i+1]
                        b.r += i + 1
                        break
                }

                // Pending error?
                if b.err != nil {
                        line = b.buf[b.r:b.w]
                        b.r = b.w
                        err = b.readErr()
                        break
                }

                // Buffer full?
                if b.Buffered() >= len(b.buf) {
                        b.r = b.w
                        line = b.buf
                        err = ErrBufferFull
                        break
                }

                b.fill() // buffer is not full
        }

        // Handle last byte, if any.
        if i := len(line) - 1; i >= 0 {
                b.lastByte = int(line[i])
                b.lastRuneSize = -1
        }

        return
}

// ReadLine is a low-level line-reading primitive. Most callers should use
// ReadBytes('\n') or ReadString('\n') instead or use a Scanner.
//
// ReadLine tries to return a single line, not including the end-of-line bytes.
// If the line was too long for the buffer then isPrefix is set and the
// beginning of the line is returned. The rest of the line will be returned
// from future calls. isPrefix will be false when returning the last fragment
// of the line. The returned buffer is only valid until the next call to
// ReadLine. ReadLine either returns a non-nil line or it returns an error,
// never both.
//
// The text returned from ReadLine does not include the line end ("\r\n" or "\n").
// No indication or error is given if the input ends without a final line end.
// Calling UnreadByte after ReadLine will always unread the last byte read
// (possibly a character belonging to the line end) even if that byte is not
// part of the line returned by ReadLine.
func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) {
        line, err = b.ReadSlice('\n')
        if err == ErrBufferFull {
                // Handle the case where "\r\n" straddles the buffer.
                if len(line) > 0 && line[len(line)-1] == '\r' {
                        // Put the '\r' back on buf and drop it from line.
                        // Let the next call to ReadLine check for "\r\n".
                        if b.r == 0 {
                                // should be unreachable
                                panic("bufio: tried to rewind past start of buffer")
                        }
                        b.r--
                        line = line[:len(line)-1]
                }
                return line, true, nil
        }

        if len(line) == 0 {
                if err != nil {
                        line = nil
                }
                return
        }
        err = nil

        if line[len(line)-1] == '\n' {
                drop := 1
                if len(line) > 1 && line[len(line)-2] == '\r' {
                        drop = 2
                }
                line = line[:len(line)-drop]
        }
        return
}

// ReadBytes reads until the first occurrence of delim in the input,
// returning a slice containing the data up to and including the delimiter.
// If ReadBytes encounters an error before finding a delimiter,
// it returns the data read before the error and the error itself (often io.EOF).
// ReadBytes returns err != nil if and only if the returned data does not end in
// delim.
// For simple uses, a Scanner may be more convenient.
func (b *Reader) ReadBytes(delim byte) ([]byte, error) {
        // Use ReadSlice to look for array,
        // accumulating full buffers.
        var frag []byte
        var full [][]byte
        var err error
        for {
                var e error
                frag, e = b.ReadSlice(delim)
                if e == nil { // got final fragment
                        break
                }
                if e != ErrBufferFull { // unexpected error
                        err = e
                        break
                }

                // Make a copy of the buffer.
                buf := make([]byte, len(frag))
                copy(buf, frag)
                full = append(full, buf)
        }

        // Allocate new buffer to hold the full pieces and the fragment.
        n := 0
        for i := range full {
                n += len(full[i])
        }
        n += len(frag)

        // Copy full pieces and fragment in.
        buf := make([]byte, n)
        n = 0
        for i := range full {
                n += copy(buf[n:], full[i])
        }
        copy(buf[n:], frag)
        return buf, err
}

// ReadString reads until the first occurrence of delim in the input,
// returning a string containing the data up to and including the delimiter.
// If ReadString encounters an error before finding a delimiter,
// it returns the data read before the error and the error itself (often io.EOF).
// ReadString returns err != nil if and only if the returned data does not end in
// delim.
// For simple uses, a Scanner may be more convenient.
func (b *Reader) ReadString(delim byte) (string, error) {
        bytes, err := b.ReadBytes(delim)
        return string(bytes), err
}

// WriteTo implements io.WriterTo.
func (b *Reader) WriteTo(w io.Writer) (n int64, err error) {
        n, err = b.writeBuf(w)
        if err != nil {
                return
        }

        if r, ok := b.rd.(io.WriterTo); ok {
                m, err := r.WriteTo(w)
                n += m
                return n, err
        }

        if w, ok := w.(io.ReaderFrom); ok {
                m, err := w.ReadFrom(b.rd)
                n += m
                return n, err
        }

        if b.w-b.r < len(b.buf) {
                b.fill() // buffer not full
        }

        for b.r < b.w {
                // b.r < b.w => buffer is not empty
                m, err := b.writeBuf(w)
                n += m
                if err != nil {
                        return n, err
                }
                b.fill() // buffer is empty
        }

        if b.err == io.EOF {
                b.err = nil
        }

        return n, b.readErr()
}

var errNegativeWrite = errors.New("bufio: writer returned negative count from Write")

// writeBuf writes the Reader's buffer to the writer.
func (b *Reader) writeBuf(w io.Writer) (int64, error) {
        n, err := w.Write(b.buf[b.r:b.w])
        if n < 0 {
                panic(errNegativeWrite)
        }
        b.r += n
        return int64(n), err
}

// buffered output

// Writer implements buffering for an io.Writer object.
// If an error occurs writing to a Writer, no more data will be
// accepted and all subsequent writes will return the error.
// After all data has been written, the client should call the
// Flush method to guarantee all data has been forwarded to
// the underlying io.Writer.
type Writer struct {
        err error
        buf []byte
        n   int
        wr  io.Writer
}

// NewWriterSize returns a new Writer whose buffer has at least the specified
// size. If the argument io.Writer is already a Writer with large enough
// size, it returns the underlying Writer.
func NewWriterSize(w io.Writer, size int) *Writer {
        // Is it already a Writer?
        b, ok := w.(*Writer)
        if ok && len(b.buf) >= size {
                return b
        }
        if size <= 0 {
                size = defaultBufSize
        }
        return &Writer{
                buf: make([]byte, size),
                wr:  w,
        }
}

// NewWriter returns a new Writer whose buffer has the default size.
func NewWriter(w io.Writer) *Writer {
        return NewWriterSize(w, defaultBufSize)
}

// Reset discards any unflushed buffered data, clears any error, and
// resets b to write its output to w.
func (b *Writer) Reset(w io.Writer) {
        b.err = nil
        b.n = 0
        b.wr = w
}

// Flush writes any buffered data to the underlying io.Writer.
func (b *Writer) Flush() error {
        if b.err != nil {
                return b.err
        }
        if b.n == 0 {
                return nil
        }
        n, err := b.wr.Write(b.buf[0:b.n])
        if n < b.n && err == nil {
                err = io.ErrShortWrite
        }
        if err != nil {
                if n > 0 && n < b.n {
                        copy(b.buf[0:b.n-n], b.buf[n:b.n])
                }
                b.n -= n
                b.err = err
                return err
        }
        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), it also returns an error explaining
// why the write is short.
func (b *Writer) Write(p []byte) (nn int, err error) {
        for len(p) > b.Available() && b.err == nil {
                var n int
                if b.Buffered() == 0 {
                        // Large write, empty buffer.
                        // Write directly from p to avoid copy.
                        n, b.err = b.wr.Write(p)
                } else {
                        n = copy(b.buf[b.n:], p)
                        b.n += n
                        b.Flush()
                }
                nn += n
                p = p[n:]
        }
        if b.err != nil {
                return nn, b.err
        }
        n := copy(b.buf[b.n:], p)
        b.n += n
        nn += n
        return nn, nil
}

// WriteByte writes a single byte.
func (b *Writer) WriteByte(c byte) 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
}

// WriteRune writes a single Unicode code point, returning
// the number of bytes written and any error.
func (b *Writer) WriteRune(r rune) (size int, err error) {
        if r < utf8.RuneSelf {
                err = b.WriteByte(byte(r))
                if err != nil {
                        return 0, err
                }
                return 1, nil
        }
        if b.err != nil {
                return 0, b.err
        }
        n := b.Available()
        if n < utf8.UTFMax {
                if b.Flush(); b.err != nil {
                        return 0, b.err
                }
                n = b.Available()
                if n < utf8.UTFMax {
                        // Can only happen if buffer is silly small.
                        return b.WriteString(string(r))
                }
        }
        size = utf8.EncodeRune(b.buf[b.n:], r)
        b.n += size
        return size, nil
}

// WriteString writes a string.
// It returns the number of bytes written.
// If the count is less than len(s), it also returns an error explaining
// why the write is short.
func (b *Writer) WriteString(s string) (int, error) {
        nn := 0
        for len(s) > b.Available() && b.err == nil {
                n := copy(b.buf[b.n:], s)
                b.n += n
                nn += n
                s = s[n:]
                b.Flush()
        }
        if b.err != nil {
                return nn, b.err
        }
        n := copy(b.buf[b.n:], s)
        b.n += n
        nn += n
        return nn, nil
}

// ReadFrom implements io.ReaderFrom.
func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) {
        if b.Buffered() == 0 {
                if w, ok := b.wr.(io.ReaderFrom); ok {
                        return w.ReadFrom(r)
                }
        }
        var m int
        for {
                if b.Available() == 0 {
                        if err1 := b.Flush(); err1 != nil {
                                return n, err1
                        }
                }
                nr := 0
                for nr < maxConsecutiveEmptyReads {
                        m, err = r.Read(b.buf[b.n:])
                        if m != 0 || err != nil {
                                break
                        }
                        nr++
                }
                if nr == maxConsecutiveEmptyReads {
                        return n, io.ErrNoProgress
                }
                b.n += m
                n += int64(m)
                if err != nil {
                        break
                }
        }
        if err == io.EOF {
                // If we filled the buffer exactly, flush preemptively.
                if b.Available() == 0 {
                        err = b.Flush()
                } else {
                        err = nil
                }
        }
        return n, err
}

// 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}
}