Golang Reader.UnreadByte方法代码示例

// Reads a single word from a file, assuming space + tab + EOL to be word boundaries
func ReadWord(fin *bufio.Reader) (word string, err error) {
	var a int = 0
	var ch byte
	var buf bytes.Buffer
	for {
		ch, err = fin.ReadByte()
		if err == io.EOF {
			break
		}
		if ch == 13 {
			continue
		}
		if (ch == ' ') || (ch == '\t') || (ch == '\n') {
			if a > 0 {
				if ch == '\n' {
					fin.UnreadByte()
				}
				break
			}
			if ch == '\n' {
				word = "</s>"
				return
			} else {
				continue
			}
		}
		buf.WriteByte(ch)
		a++
	}
	if a >= MAX_STRING { // Truncate too long words
		buf.Truncate(MAX_STRING)
	}
	word = buf.String()
	return
}

func readHexInt(r *bufio.Reader) (int, error) {
	n := 0
	i := 0
	var k int
	for {
		c, err := r.ReadByte()
		if err != nil {
			if err == io.EOF && i > 0 {
				return n, nil
			}
			return -1, err
		}
		k = hexbyte2int(c)
		if k < 0 {
			if i == 0 {
				return -1, fmt.Errorf("cannot read hex num from empty string")
			}
			r.UnreadByte()
			return n, nil
		}
		if i >= maxHexIntChars {
			return -1, fmt.Errorf("cannot read hex num with more than %d digits", maxHexIntChars)
		}
		n = (n << 4) | k
		i++
	}
}

// read reads the next value, ignoring whitespace.
func read(r *bufio.Reader) []byte {
	var comment bool
	space(r)

	buf := make([]byte, 0, 16)

loop:
	for {
		b, err := r.ReadByte()
		check(err)

		switch {
		case b == '#':
			comment = true
		case (comment && isNewline(b)) || (!comment && isSpace(b)):
			check(r.UnreadByte())
			break loop
		}

		if !comment {
			buf = append(buf, b)
		}
	}

	if len(buf) == 0 {
		return read(r)
	}

	return buf
}

func readHexInt(r *bufio.Reader) (int, error) {
	n := 0
	i := 0
	var k int
	for {
		c, err := r.ReadByte()
		if err != nil {
			if err == io.EOF && i > 0 {
				return n, nil
			}
			return -1, err
		}
		k = hexbyte2int(c)
		if k < 0 {
			if i == 0 {
				return -1, errEmptyHexNum
			}
			r.UnreadByte()
			return n, nil
		}
		if i >= maxHexIntChars {
			return -1, errTooLargeHexNum
		}
		n = (n << 4) | k
		i++
	}
}

func read_symbol(b *bufio.Reader) (goscm.SCMT, error) {
	ret := ""
	var c byte
	var err error

	for {
		c, err = b.ReadByte()
		if err != nil {
			break
		}
		if c == ')' {
			b.UnreadByte()
			break
		}
		if c == ';' {
			read_comment(b)
			continue
		}
		if is_whitespace(c) {
			break
		}
		ret = string(append([]byte(ret), c))
	}
	return goscm.NewSymbol(ret), err
}

func (p *protocol) ReadParam(r *bufio.Reader) ([]byte, bool, error) {
	data, err := r.ReadSlice('\r')
	if err != nil {
		return nil, false, p.sanitizeErr(err)
	}
	err = p.assumeByte(r, '\n')
	if err != nil {
		return nil, false, err
	}

	next, err := r.ReadByte()
	if err != nil {
		return nil, false, p.sanitizeErr(err)
	}
	hasNext := true
	if next == '\r' {
		hasNext = false
		err = p.assumeByte(r, '\n')
		if err != nil {
			return nil, false, p.sanitizeErr(err)
		}
	} else {
		r.UnreadByte()
	}

	return data, hasNext, nil
}

// skipComments skips all comments (and whitespace) that may occur between PNM
// header tokens.
//
// The singleSpace argument is used to scan comments between the header and the
// raster data where only a single whitespace delimiter is allowed. This
// prevents scanning the image data.
func skipComments(r *bufio.Reader, singleSpace bool) (err error) {
	var c byte

	for {
		// Skip whitespace
		c, err = r.ReadByte()
		for unicode.IsSpace(rune(c)) {
			if c, err = r.ReadByte(); err != nil {
				return err
			}
			if singleSpace {
				break
			}
		}
		// If there are no more comments, unread the last byte and return.
		if c != '#' {
			r.UnreadByte()
			return nil
		}
		// A comment ends with a newline or carriage return.
		for c != '\n' && c != '\r' {
			if c, err = r.ReadByte(); err != nil {
				return
			}
		}
	}
	return
}

func isEndOfString(br *bufio.Reader) (ended bool, text string, err error) {
	var b byte
	w := bytes.NewBufferString("")
	for {
		switch b, err = br.ReadByte(); {
		case err == io.EOF:
			ended = true
			err = nil
			return
		case err != nil:
			return
		case b == ',' || b == ']':
			br.UnreadByte()
			ended = true
			return
		case !unicode.IsSpace(rune(b)):
			ended = false
			text = w.String()
			err = nil
			br.UnreadByte()
			return
		}
		w.WriteByte(b)
	}
	return
}

func Decode(input *bufio.Reader) (_ string, err error) {
	buf := bytes.NewBufferString("")
	for {
		b, err := input.ReadByte()
		if err != nil {
			break
		}
		if b != '=' {
			err = buf.WriteByte(b)
		} else {
			input.UnreadByte()
			charset, err := readCharset(input)
			if err != nil {
				return "", err
			}
			encoding, err := readEncoding(input)
			if err != nil {
				return "", err
			}
			(&Decoder{encoding, charset}).Decode(input, buf)
		}
	}
	if err == io.EOF {
		return buf.String(), nil
	}
	return buf.String(), err
}

func peek(r *bufio.Reader) (c byte, e error) {
	c, e = r.ReadByte()
	if e != io.EOF {
		r.UnreadByte()
	}
	return
}

func expect(r *bufio.Reader, c byte) bool {
	ReadWhitespace(r)
	res, err := r.ReadByte()
	if res != c {
		r.UnreadByte()
	}

	return res == c && err != io.EOF
}

func genericExpect(br *bufio.Reader, what string, predicate func(byte) bool) error {
	switch b, err := br.ReadByte(); {
	case err != nil:
		return err
	case !predicate(b):
		br.UnreadByte()
		return NewErrExpect(br, what)
	}
	return nil
}

func skip(rd *bufio.Reader) {
	var b byte = ' '
	var err error
	for b == ' ' || b == '\t' || b == '\n' {
		b, err = rd.ReadByte()
		if err != nil {
			return
		}
	}
	rd.UnreadByte()
}

// space reads whitespace from the given reader, until
// the stream ends or a non-whitespace character is found.
func space(r *bufio.Reader) {
	for {
		b, err := r.ReadByte()
		check(err)

		if !isSpace(b) {
			check(r.UnreadByte())
			return
		}
	}
}

//Peek and check if packet is EOF
func peekEOF(br *bufio.Reader) (bool, os.Error) {
	b, err := br.ReadByte()
	if err != nil {
		return false, err
	}
	err = br.UnreadByte()
	if b == 0xfe {
		return true, err
	}
	return false, err
}