parser.go

package parser

import (
	"bytes"
	"strconv"

	"github.com/go-pg/pg/internal"
)

type Parser struct {
	data []byte
	pos  int

	b []byte
}

func New(b []byte) *Parser {
	return &Parser{
		data: b,
		b:    b,
	}
}

func NewString(s string) *Parser {
	return New(internal.StringToBytes(s))
}

func (p *Parser) Bytes() []byte {
	return p.b
}

func (p *Parser) Position() int {
	return p.pos
}

func (p *Parser) PositionByte(c byte) int {
	ind := bytes.IndexByte(p.b, c)
	if ind == -1 {
		return len(p.data)
	}
	return p.pos + ind
}

func (p *Parser) Slice(s, e int) []byte {
	b := p.data[s:e]
	p.pos = e
	p.b = p.data[e:]
	return b
}

func (p *Parser) Valid() bool {
	return len(p.b) > 0
}

func (p *Parser) Read() byte {
	if p.Valid() {
		c := p.b[0]
		p.Skip(c)
		return c
	}
	return 0
}

func (p *Parser) Peek() byte {
	if p.Valid() {
		return p.b[0]
	}
	return 0
}

func (p *Parser) Advance() {
	p.pos++
	p.b = p.b[1:]
}

func (p *Parser) Skip(c byte) bool {
	if p.Peek() == c {
		p.Advance()
		return true
	}
	return false
}

func (p *Parser) SkipBytes(b []byte) bool {
	if len(b) > len(p.b) {
		return false
	}
	if !bytes.Equal(p.b[:len(b)], b) {
		return false
	}
	p.pos += len(b)
	p.b = p.b[len(b):]
	return true
}

func (p *Parser) ReadSep(c byte) ([]byte, bool) {
	ind := bytes.IndexByte(p.b, c)
	if ind == -1 {
		b := p.b
		p.pos = len(p.b)
		p.b = p.b[len(p.b):]
		return b, false
	}

	b := p.b[:ind]
	p.pos += ind + 1
	p.b = p.b[ind+1:]
	return b, true
}

func (p *Parser) ReadIdentifier() (s string, numeric bool) {
	end := len(p.b)
	numeric = true
	for i, ch := range p.b {
		if isNum(ch) {
			continue
		}
		if isAlpha(ch) || ch == '_' {
			numeric = false
			continue
		}
		end = i
		break
	}
	if end <= 0 {
		return "", false
	}
	b := p.b[:end]
	p.pos += end
	p.b = p.b[end:]
	return internal.BytesToString(b), numeric
}

func (p *Parser) ReadNumber() int {
	end := len(p.b)
	for i, ch := range p.b {
		if !isNum(ch) {
			end = i
			break
		}
	}
	if end <= 0 {
		return 0
	}
	n, _ := strconv.Atoi(string(p.b[:end]))
	p.pos += end
	p.b = p.b[end:]
	return n
}

func (p *Parser) readSubstring() []byte {
	var b []byte
	for p.Valid() {
		c := p.Read()
		switch c {
		case '\\':
			switch p.Peek() {
			case '\\':
				b = append(b, '\\')
				p.Advance()
			case '"':
				b = append(b, '"')
				p.Advance()
			default:
				b = append(b, c)
			}
		case '\'':
			switch p.Peek() {
			case '\'':
				b = append(b, '\'')
				p.Skip(c)
			default:
				b = append(b, c)
			}
		case '"':
			return b
		default:
			b = append(b, c)
		}
	}
	return b
}