summaryrefslogtreecommitdiff
path: root/src/pkg/bufio/bufio.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/bufio/bufio.go')
-rw-r--r--src/pkg/bufio/bufio.go158
1 files changed, 79 insertions, 79 deletions
diff --git a/src/pkg/bufio/bufio.go b/src/pkg/bufio/bufio.go
index 895dbf6e7..5b71182c4 100644
--- a/src/pkg/bufio/bufio.go
+++ b/src/pkg/bufio/bufio.go
@@ -22,7 +22,7 @@ import (
// - buffered output
const (
- defaultBufSize = 4096
+ defaultBufSize = 4096;
)
// Errors introduced by this package.
@@ -31,20 +31,21 @@ type Error struct {
}
var (
- ErrInvalidUnreadByte os.Error = &Error{"bufio: invalid use of UnreadByte"};
- ErrBufferFull os.Error = &Error{"bufio: buffer full"};
- errInternal os.Error = &Error{"bufio: internal error"};
+ 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]
+ dst[i] = src[i];
}
}
@@ -53,11 +54,11 @@ func copySlice(dst []byte, src []byte) {
// Reader implements buffering for an io.Reader object.
type Reader struct {
- buf []byte;
- rd io.Reader;
- r, w int;
- err os.Error;
- lastbyte int;
+ buf []byte;
+ rd io.Reader;
+ r, w int;
+ err os.Error;
+ lastbyte int;
}
// NewReaderSize creates a new Reader whose buffer has the specified size,
@@ -66,18 +67,18 @@ type Reader struct {
// It returns the Reader and any error.
func NewReaderSize(rd io.Reader, size int) (*Reader, os.Error) {
if size <= 0 {
- return nil, BufSizeError(size)
+ return nil, BufSizeError(size);
}
// Is it already a Reader?
b, ok := rd.(*Reader);
if ok && len(b.buf) >= size {
- return b, nil
+ return b, nil;
}
b = new(Reader);
b.buf = make([]byte, size);
b.rd = rd;
b.lastbyte = -1;
- return b, nil
+ return b, nil;
}
// NewReader returns a new Reader whose buffer has the default size.
@@ -94,15 +95,15 @@ func NewReader(rd io.Reader) *Reader {
func (b *Reader) fill() {
// Slide existing data to beginning.
if b.w > b.r {
- copySlice(b.buf[0:b.w-b.r], b.buf[b.r:b.w]);
+ copySlice(b.buf[0 : b.w - b.r], b.buf[b.r : b.w]);
b.w -= b.r;
} else {
- b.w = 0
+ b.w = 0;
}
b.r = 0;
// Read new data.
- n, e := b.rd.Read(b.buf[b.w:len(b.buf)]);
+ n, e := b.rd.Read(b.buf[b.w : len(b.buf)]);
b.w += n;
if e != nil {
b.err = e;
@@ -120,7 +121,7 @@ func (b *Reader) Read(p []byte) (nn int, err os.Error) {
n := len(p);
if b.w == b.r {
if b.err != nil {
- return nn, b.err
+ return nn, b.err;
}
if len(p) >= len(b.buf) {
// Large read, empty buffer.
@@ -137,15 +138,15 @@ func (b *Reader) Read(p []byte) (nn int, err os.Error) {
continue;
}
if n > b.w - b.r {
- n = b.w - b.r
+ n = b.w - b.r;
}
- copySlice(p[0:n], b.buf[b.r:b.r+n]);
+ 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
+ b.lastbyte = int(b.buf[b.r - 1]);
+ nn += n;
}
- return nn, nil
+ return nn, nil;
}
// ReadByte reads and returns a single byte.
@@ -153,14 +154,14 @@ func (b *Reader) Read(p []byte) (nn int, err os.Error) {
func (b *Reader) ReadByte() (c byte, err os.Error) {
for b.w == b.r {
if b.err != nil {
- return 0, b.err
+ return 0, b.err;
}
b.fill();
}
c = b.buf[b.r];
b.r++;
b.lastbyte = int(c);
- return c, nil
+ return c, nil;
}
// UnreadByte unreads the last byte. Only the most recently read byte can be unread.
@@ -173,17 +174,17 @@ func (b *Reader) UnreadByte() os.Error {
return nil;
}
if b.r <= 0 {
- return ErrInvalidUnreadByte
+ return ErrInvalidUnreadByte;
}
b.r--;
b.lastbyte = -1;
- return nil
+ 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]) && b.err == nil {
+ for b.r + utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r : b.w]) && b.err == nil {
b.fill();
}
if b.r == b.w {
@@ -191,11 +192,11 @@ func (b *Reader) ReadRune() (rune int, size int, err os.Error) {
}
rune, size = int(b.buf[b.r]), 1;
if rune >= 0x80 {
- rune, size = utf8.DecodeRune(b.buf[b.r:b.w]);
+ 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
+ b.lastbyte = int(b.buf[b.r - 1]);
+ return rune, size, nil;
}
// Helper function: look for byte c in array p,
@@ -203,10 +204,10 @@ func (b *Reader) ReadRune() (rune int, size int, err os.Error) {
func findByte(p []byte, c byte) int {
for i := 0; i < len(p); i++ {
if p[i] == c {
- return i
+ return i;
}
}
- return -1
+ return -1;
}
// Buffered returns the number of bytes that can be read from the current buffer.
@@ -226,33 +227,33 @@ func (b *Reader) Buffered() int {
// ReadSlice returns err != nil if and only if line does not end in delim.
func (b *Reader) ReadSlice(delim byte) (line []byte, err os.Error) {
// Look in buffer.
- if i := findByte(b.buf[b.r:b.w], delim); i >= 0 {
- line1 := b.buf[b.r:b.r+i+1];
+ 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
+ return line1, nil;
}
// Read more into buffer, until buffer fills or we find delim.
for {
if b.err != nil {
- line := b.buf[b.r:b.w];
+ line := b.buf[b.r : b.w];
b.r = b.w;
- return line, b.err
+ return line, b.err;
}
n := b.Buffered();
b.fill();
// Search new part of buffer
- if i := findByte(b.buf[n:b.w], delim); i >= 0 {
- line := b.buf[0:n+i+1];
+ 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
+ return line, nil;
}
// Buffer is full?
if b.Buffered() >= len(b.buf) {
- return nil, ErrBufferFull
+ return nil, ErrBufferFull;
}
}
panic("not reached");
@@ -275,11 +276,11 @@ func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
var e os.Error;
frag, e = b.ReadSlice(delim);
if e == nil { // got final fragment
- break
+ break;
}
if e != ErrBufferFull { // unexpected error
err = e;
- break
+ break;
}
// Read bytes out of buffer.
@@ -289,12 +290,12 @@ func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
if e != nil {
frag = buf[0:n];
err = e;
- break
+ break;
}
if n != len(buf) {
frag = buf[0:n];
err = errInternal;
- break
+ break;
}
// Grow list if needed.
@@ -305,7 +306,7 @@ func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
for i := 0; i < len(full); i++ {
newfull[i] = full[i];
}
- full = newfull
+ full = newfull;
}
// Save buffer
@@ -316,7 +317,7 @@ func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
// 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(full[i]);
}
n += len(frag);
@@ -324,11 +325,11 @@ func (b *Reader) ReadBytes(delim byte) (line []byte, err os.Error) {
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(full[i])], full[i]);
+ n += len(full[i]);
}
- copySlice(buf[n:n+len(frag)], frag);
- return buf, err
+ copySlice(buf[n : n+len(frag)], frag);
+ return buf, err;
}
// ReadString reads until the first occurrence of delim in the input,
@@ -346,10 +347,10 @@ func (b *Reader) ReadString(delim byte) (line string, err os.Error) {
// Writer implements buffering for an io.Writer object.
type Writer struct {
- err os.Error;
- buf []byte;
- n int;
- wr io.Writer;
+ err os.Error;
+ buf []byte;
+ n int;
+ wr io.Writer;
}
// NewWriterSize creates a new Writer whose buffer has the specified size,
@@ -358,17 +359,17 @@ type Writer struct {
// It returns the Writer and any error.
func NewWriterSize(wr io.Writer, size int) (*Writer, os.Error) {
if size <= 0 {
- return nil, BufSizeError(size)
+ return nil, BufSizeError(size);
}
// Is it already a Writer?
b, ok := wr.(*Writer);
if ok && len(b.buf) >= size {
- return b, nil
+ return b, nil;
}
b = new(Writer);
b.buf = make([]byte, size);
b.wr = wr;
- return b, nil
+ return b, nil;
}
// NewWriter returns a new Writer whose buffer has the default size.
@@ -384,32 +385,32 @@ func NewWriter(wr io.Writer) *Writer {
// Flush writes any buffered data to the underlying io.Writer.
func (b *Writer) Flush() os.Error {
if b.err != nil {
- return b.err
+ return b.err;
}
- n, e := b.wr.Write(b.buf[0:b.n]);
+ 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])
+ copySlice(b.buf[0 : b.n - n], b.buf[n : b.n]);
}
b.n -= n;
b.err = e;
- return e
+ return e;
}
b.n = 0;
- return nil
+ return nil;
}
// Available returns how many bytes are unused in the buffer.
func (b *Writer) Available() int {
- return len(b.buf) - b.n
+ 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
+ return b.n;
}
// Write writes the contents of p into the buffer.
@@ -418,16 +419,16 @@ func (b *Writer) Buffered() int {
// why the write is short.
func (b *Writer) Write(p []byte) (nn int, err os.Error) {
if b.err != nil {
- return 0, b.err
+ return 0, b.err;
}
nn = 0;
for len(p) > 0 {
n := b.Available();
if n <= 0 {
if b.Flush(); b.err != nil {
- break
+ break;
}
- n = b.Available()
+ n = b.Available();
}
if b.Available() == 0 && len(p) >= len(b.buf) {
// Large write, empty buffer.
@@ -441,33 +442,33 @@ func (b *Writer) Write(p []byte) (nn int, err os.Error) {
continue;
}
if n > len(p) {
- n = len(p)
+ n = len(p);
}
- copySlice(b.buf[b.n:b.n+n], p[0:n]);
+ copySlice(b.buf[b.n : b.n + n], p[0:n]);
b.n += n;
nn += n;
- p = p[n:len(p)]
+ p = p[n:len(p)];
}
- return nn, b.err
+ return nn, b.err;
}
// WriteByte writes a single byte.
func (b *Writer) WriteByte(c byte) os.Error {
if b.err != nil {
- return b.err
+ return b.err;
}
if b.Available() <= 0 && b.Flush() != nil {
- return b.err
+ return b.err;
}
b.buf[b.n] = c;
b.n++;
- return nil
+ return nil;
}
// WriteString writes a string.
func (b *Writer) WriteString(s string) os.Error {
if b.err != nil {
- return b.err
+ return b.err;
}
// Common case, worth making fast.
if b.Available() >= len(s) || len(b.buf) >= len(s) && b.Flush() == nil {
@@ -480,7 +481,7 @@ func (b *Writer) WriteString(s string) os.Error {
for i := 0; i < len(s); i++ { // loop over bytes, not runes.
b.WriteByte(s[i]);
}
- return b.err
+ return b.err;
}
// buffered input and output
@@ -494,6 +495,5 @@ type ReadWriter struct {
// NewReadWriter allocates a new ReadWriter that dispatches to r and w.
func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
- return &ReadWriter{r, w}
+ return &ReadWriter{r, w};
}
-
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-05 11:41:14 +0000