func (src *Source) consume() {
	if src.reader == nil {
		src.ReportError(io.EOF)
		return
	}
	n, err := src.reader.Read(src.buf)
	if err != nil || n == 0 {
		src.ReportError(err)
		return
	}
	src.readBytes = append(src.readBytes, src.buf[:n]...)
}
consume will fill the readBytes with more bytes from reader
package parse
import (
	"bytes"
	"errors"
	"io"
	"io/ioutil"
	"unicode/utf8"
)
type stack struct {
	buf []breakInfo
}
type breakInfo struct {
	nextIdx int
}
func (s *stack) Push(info breakInfo) {
	s.buf = append(s.buf, info)
}
func (s *stack) Pop() breakInfo {
	last := len(s.buf) - 1
	brkInfo := s.buf[last]
	s.buf = s.buf[:last]
	return brkInfo
}
func (s *stack) Empty() bool {
	return len(s.buf) == 0
}
type Source struct {
	err            error
	reader         io.Reader
	readBytes      []byte
	buf            []byte
	nextIdx        int
	savepointStack *stack
}
const (
	_maxBufLen = 40
)
func NewSource(reader io.Reader, bufLen int) (*Source, error) {
	if bufLen > _maxBufLen {
		bufLen = _maxBufLen
	}
	buf := make([]byte, bufLen)
	n, err := reader.Read(buf)
	if n == 0 {
		return nil, err
	}
	readByes := make([]byte, n)
	copy(readByes, buf)
	return &Source{
		reader:         reader,
		readBytes:      readByes,
		buf:            buf,
		savepointStack: new(stack),
	}, nil
}
func NewSourceString(str string) (*Source, error) {
	if len(str) == 0 {
		return nil, errors.New("source string is empty")
	}
	reader := bytes.NewReader([]byte(str))
	return NewSource(reader, _maxBufLen)
}
func (src *Source) StoreSavepoint() {
	src.savepointStack.Push(breakInfo{nextIdx: src.nextIdx})
}
var errNoSavepoint = errors.New("no savepoint in stack")
func (src *Source) DeleteSavepoint() {
	if src.savepointStack.Empty() {
		src.ReportError(errNoSavepoint)
		return
	}
	src.savepointStack.Pop()
}
func (src *Source) RollbackToSavepoint() {
	if src.savepointStack.Empty() {
		src.ReportError(errNoSavepoint)
		return
	}
	brkInfo := src.savepointStack.Pop()
	src.nextIdx = brkInfo.nextIdx
	src.err = nil
}
func (src *Source) Peek1() byte {
	if src.Error() != nil {
		return 0x0
	}
	if src.nextIdx < len(src.readBytes) {
		return src.readBytes[src.nextIdx]
	}
	src.consume()
	if src.nextIdx < len(src.readBytes) {
		return src.readBytes[src.nextIdx]
	}
	src.ReportError(io.ErrUnexpectedEOF)
	return 0x0  
}
func (src *Source) Peek() []byte {
	return src.readBytes[src.nextIdx:]
}
func (src *Source) PeekAll() []byte {
	data, _ := ioutil.ReadAll(src.reader)
	if len(data) > 0 {
		src.readBytes = append(src.readBytes, data...)
	}
	return src.readBytes[src.nextIdx:]
}
func (src *Source) PeekN(n int) []byte {
	rest := len(src.readBytes) - src.nextIdx
	for src.Error() == nil && rest < n {
		src.consume()
		rest = len(src.readBytes) - src.nextIdx
	}
	if rest >= n {
		return src.readBytes[src.nextIdx : src.nextIdx+n]
	}
	src.ReportError(io.ErrUnexpectedEOF)
	return src.readBytes[src.nextIdx:]
}
func (src *Source) ReadByte() (byte, error) {
	return src.Read1(), src.Error()
}
func (src *Source) Read1() byte {
	if src.Error() != nil {
		return 0x0
	}
	b := src.Peek1()
	if src.Error() == nil {
		src.nextIdx++
	}
	return b
}
func (src *Source) ReadN(n int) []byte {
	if src.Error() != nil {
		return nil
	}
	buf := src.PeekN(n)
	src.nextIdx += len(buf)
	return buf
}
func (src *Source) ReadAll() []byte {
	buf := src.PeekAll()
	src.nextIdx += len(buf)
	return buf
}
var errExpectedBytesNotFound = errors.New(`expected bytes not found`)
func (src *Source) Expect1(b1 byte) bool {
	if src.Peek1() == b1 {
		src.nextIdx++
		return true
	}
	return false
}
func (src *Source) Expect2(b1, b2 byte) bool {
	buf := src.PeekN(2)
	if len(buf) < 2 {
		return false
	}
	if buf[0] == b1 && buf[1] == b2 {
		src.nextIdx += 2
		return true
	}
	return false
}
func (src *Source) Expect3(b1, b2, b3 byte) bool {
	buf := src.PeekN(3)
	if len(buf) < 3 {
		return false
	}
	if buf[0] == b1 && buf[1] == b2 && buf[2] == b3 {
		src.nextIdx += 3
		return true
	}
	return false
}
func (src *Source) Expect4(b1, b2, b3, b4 byte) bool {
	buf := src.PeekN(4)
	if len(buf) < 4 {
		return false
	}
	if buf[0] == b1 && buf[1] == b2 && buf[2] == b3 && buf[3] == b4 {
		src.nextIdx += 4
		return true
	}
	return false
}
func (src *Source) Expect(expect []byte) bool {
	buf := src.PeekN(len(expect))
	if len(buf) < len(expect) {
		return false
	}
	for i, e := range expect {
		if buf[i] != e {
			return false
		}
	}
	src.nextIdx += len(expect)
	return true
}