Golang Reader.UnreadRune方法代码示例

func skipWS(reader *bufio.Reader) (eof bool) {
	eof = false
	for {
		rune, size, _ := reader.ReadRune()
		if size == 0 {
			eof = true
			break
		}
		if rune == 32 {
			continue
		}
		if rune == 13 {
			continue
		}
		if rune == 10 {
			continue
		}
		if rune == 9 {
			continue
		}
		reader.UnreadRune()
		break
	}
	return eof
}

// Parse a address greedily from the buffer, if the first non-witespace
// token found is not a valid start of an adr nil, nil is returned
// If a valid adr is parsed, !nil, nil is returned
// If there is an error whilst parsing the addr nil, !nil is returned
// Note that it will consume all spaces in the buffer to check the next char
func Parse(b *bufio.Reader) (*Node, error) {
	// TODO: Change from bytes.Bufer to something nicer... Best is an interface..
	//Check for start, is it the start of an adr
	tl := newLexer(b)
	tl.consume(unicode.IsSpace)
	r, _, e := b.ReadRune()
	if e != nil {
		return nil, nil
	}
	b.UnreadRune()
	if !(unicode.IsDigit(r) ||
		r == '/' ||
		r == '+' ||
		r == '-' ||
		r == '.' ||
		r == '$' ||
		r == '\'' ||
		r == '#' ||
		r == ',' ||
		r == ';') {
		return nil, nil
	}

	fullNode = nil
	l := newLexer(b)
	ok := yyParse(l)
	if ok != 0 {
		// There was an error whils parsing:
		return nil, err
	}
	return fullNode, nil
}

func preprocess(buf []byte, r *bufio.Reader) (int, error) {
	i := 0
	for c, n, err := r.ReadRune(); err == nil; c, n, err = r.ReadRune() {
		if i+n > len(buf) {
			// We don't have room so unread the rune and return.
			r.UnreadRune()
			return i, err
		}
		switch c {
		case '\x00':
			if len(buf)-1 < i+len(unknownRune) {
				copy(buf[i:len(unknownRune)], unknownRune)
			} else {
				// We don't have room so unread the rune and
				// return.
				r.UnreadRune()
				return i + n, err
			}
		case '\r':
			buf[i] = '\n'
			nxt, err := r.Peek(1)
			if err == nil && len(nxt) == 1 && nxt[0] == '\n' {
				r.ReadByte()
			}
		case '\f':
			buf[i] = '\n'
		default:
			copy(buf[i:i+n], []byte(string(c)))
		}
		i += n
	}
	return i, nil
}

func nextLine(f *bufio.Reader) {
	// Consume whitespace
	for {
		r, _, err := f.ReadRune()
		if err != nil {
			if err == io.EOF {
				return
			}
			panic(err.Error())
		}
		if r != ' ' && r != '\t' {
			f.UnreadRune()
			break
		}
	}
	// Consume any number of endline runes
	for {
		r, _, err := f.ReadRune()
		if err != nil {
			if err == io.EOF {
				return
			}
			panic(err.Error())
		}
		if r != '\r' && r != '\n' {
			f.UnreadRune()
			return
		}
	}
}

// translate Esc[X
func escapeExKey(r rune, reader *bufio.Reader) rune {
	switch r {
	case 'D':
		r = CharBackward
	case 'C':
		r = CharForward
	case 'A':
		r = CharPrev
	case 'B':
		r = CharNext
	case 'H':
		r = CharLineStart
	case 'F':
		r = CharLineEnd
	default:
		if r == '3' && reader != nil {
			d, _, _ := reader.ReadRune()
			if d == '~' {
				r = CharDelete
			} else {
				reader.UnreadRune()
			}
		}
	}
	return r
}

func (p *parser) nextToken(reader *bufio.Reader) (string, syms.SymbolID) {
	var sid stateID
	var str bytes.Buffer
	s := p.all[sid]
	for {
		r, _, err := reader.ReadRune()
		if err != nil {
			if sid == 0 {
				if err == io.EOF {
					return "", syms.EOF
				}
				return "", syms.ERROR
			}
			return str.String(), s.id
		}
		sid = s.tr[r]
		if sid == 0 {
			// fmt.Println("nextToken: unaccepted ", string(r), " returning ", s.id)
			reader.UnreadRune()
			return str.String(), s.id
		}
		// fmt.Println("nextToken: move via ", string(r), " to ", sid)
		s = p.all[sid]
		str.WriteRune(r)
	}
}

// translate EscX to Meta+X
func escapeKey(r rune, reader *bufio.Reader) rune {
	switch r {
	case 'b':
		r = MetaBackward
	case 'f':
		r = MetaForward
	case 'd':
		r = MetaDelete
	case CharTranspose:
		r = MetaTranspose
	case CharBackspace:
		r = MetaBackspace
	case 'O':
		d, _, _ := reader.ReadRune()
		switch d {
		case 'H':
			r = CharLineStart
		case 'F':
			r = CharLineEnd
		default:
			reader.UnreadRune()
		}
	case CharEsc:

	}
	return r
}

func (sr *StandardReader) NextIdentifier(in *bufio.Reader) string {
	var id []rune
	if sr.cIdentifier != "" {
		rv := sr.cIdentifier
		sr.cIdentifier = ""
		return rv
	}
	for {
		c, _, err := in.ReadRune()
		if err != nil {
			if len(id) != 0 {
				break
			}
			sr.Error(errors.New(fmt.Sprintf("expected identifier (%s)", err.Error())))
		}
		var ok bool
		if len(id) == 0 {
			ok = sr.IdentifierStart(c)
		} else {
			ok = sr.IdentifierPart(c)
		}
		if !ok {
			in.UnreadRune()
			if len(id) == 0 {
				break
			}
			sr.Error(errors.New(fmt.Sprintf("expected identifier (%s)", err.Error())))
		}
		sr.pos += 1
		sr.col += 1
		id = append(id, c)
	}
	return string(id)
}

func readSexp(r *bufio.Reader) (*Sexp, error) {
	// read ( or atom
	c, _, err := r.ReadRune()
	if err != nil {
		return nil, err
	} else if c != '(' {
		r.UnreadRune()
		return readAtom(r)
	}

	// read two space-separated Sexps
	x, err := readSexp(r)
	if err != nil {
		return nil, err
	}
	if err = expect(r, ' '); err != nil {
		return nil, err
	}
	y, err := readSexp(r)
	if err != nil {
		return nil, err
	}

	// read )
	if err = expect(r, ')'); err != nil {
		return nil, err
	}

	return &Sexp{X: x, Y: y}, nil
}

func parse(r *bufio.Reader, line, col *int, inList bool) (n Node, err error) {

	err = readSeparator(r, List, line, col)
	if err != nil {
		return
	}

	c, _, err := r.ReadRune()
	checkNewline(c, line, col)
	switch c {
	case comment:
		err = readComment(r, line, col)
	case listStart:
		n, err = readList(r, line, col)
	case listEnd:
		r.UnreadRune()
	case groupStart:
		n, err = readGroup(r, line, col)
	case groupEnd:
		r.UnreadRune()
	default:
		n, err = readWord(r, line, col)
	}

	return
}

func (sr *StandardReader) TestPeek(in *bufio.Reader, c rune) bool {
	c0, _, err := in.ReadRune()
	if err != nil {
		return false
	}
	in.UnreadRune()
	return c == c0
}

func checkEmpty(data *bufio.Reader) (err error) {
	if _, _, err = data.ReadRune(); err != nil {
		return errors.New("unable to locate front matter")
	}
	if err = data.UnreadRune(); err != nil {
		return errors.New("unable to unread first charactor in page buffer.")
	}
	return
}

// PeeKNext peek next valid (non space) rune from an input buffer.
func peekNext(in *bufio.Reader) (rune, error) {
	if err := skipSpaces(in); err != nil {
		return rune(0), err
	}
	r, _, err := in.ReadRune()
	if err != nil {
		return rune(0), err
	}
	in.UnreadRune()
	return r, nil
}

// SkipSpaces skip spaces from an input buffer.
func skipSpaces(in *bufio.Reader) error {
	for {
		r, _, err := in.ReadRune()
		if err != nil {
			return err
		}
		if !unicode.IsSpace(r) {
			in.UnreadRune()
			return nil
		}
	}
}

func consumeSpaces(in *bufio.Reader) (n int64, err error) {
	r := ' '
	var c int
	for unicode.IsSpace(r) {
		n += int64(c)
		r, c, err = in.ReadRune()
		if err != nil {
			return
		}
	}
	err = in.UnreadRune()
	return
}