107 lines
2.5 KiB
Go
107 lines
2.5 KiB
Go
package parsekit
|
|
|
|
import (
|
|
"fmt"
|
|
)
|
|
|
|
// Result holds results as produced by a TokenHandler.
|
|
type Result struct {
|
|
lastRune *runeInfo // Information about the last rune read using NextRune()
|
|
runes []rune
|
|
tokens []*Token
|
|
}
|
|
|
|
type runeInfo struct {
|
|
r rune
|
|
err error
|
|
}
|
|
|
|
// Token defines a lexical token as produced by TokenHandlers.
|
|
type Token struct {
|
|
Type interface{} // token type, can be any type that a parser author sees fit
|
|
Runes []rune // the runes that make up the token
|
|
Value interface{} // an optional value of any type
|
|
}
|
|
|
|
// NewResult initializes an empty result struct.
|
|
func NewResult() *Result {
|
|
return &Result{
|
|
runes: []rune{},
|
|
tokens: []*Token{},
|
|
}
|
|
}
|
|
|
|
// ClearRunes clears the runes in the Result.
|
|
func (r *Result) ClearRunes() {
|
|
r.runes = []rune{}
|
|
}
|
|
|
|
// SetRunes replaces the Runes from the Result with the provided input.
|
|
func (r *Result) SetRunes(s interface{}) {
|
|
r.ClearRunes()
|
|
r.AddRunes(s)
|
|
}
|
|
|
|
// AddRunes is used to add runes to the Result.
|
|
func (r *Result) AddRunes(s interface{}) {
|
|
switch s := s.(type) {
|
|
case string:
|
|
r.runes = append(r.runes, []rune(s)...)
|
|
case []rune:
|
|
r.runes = append(r.runes, s...)
|
|
case rune:
|
|
r.runes = append(r.runes, s)
|
|
default:
|
|
panic(fmt.Sprintf("parsekit.Result.SetRunes(): unsupported type '%T' used", s))
|
|
}
|
|
}
|
|
|
|
// Runes retrieves the Runes from the Result.
|
|
func (r *Result) Runes() []rune {
|
|
return r.runes
|
|
}
|
|
|
|
// Rune retrieve a single rune from the Result at the specified index.
|
|
func (r *Result) Rune(idx int) rune {
|
|
return r.runes[idx]
|
|
}
|
|
|
|
// String returns the Runes from the Result as a string.
|
|
func (r *Result) String() string {
|
|
return string(r.runes)
|
|
}
|
|
|
|
// ClearTokens clears the tokens in the Result.
|
|
func (r *Result) ClearTokens() {
|
|
r.tokens = []*Token{}
|
|
}
|
|
|
|
// AddToken is used to add a Token to the results.
|
|
func (r *Result) AddToken(t *Token) {
|
|
r.tokens = append(r.tokens, t)
|
|
}
|
|
|
|
// Tokens retrieves the Tokens from the Result.
|
|
func (r *Result) Tokens() []*Token {
|
|
return r.tokens
|
|
}
|
|
|
|
// Token retrieves a single Token from the Result at the specified index.
|
|
func (r *Result) Token(idx int) *Token {
|
|
return r.tokens[idx]
|
|
}
|
|
|
|
// Values retrieves a slice containing only the Values for the Result Tokens.
|
|
func (r *Result) Values() []interface{} {
|
|
values := make([]interface{}, len(r.tokens))
|
|
for i, tok := range r.tokens {
|
|
values[i] = tok.Value
|
|
}
|
|
return values
|
|
}
|
|
|
|
// Value retrieves a single Value from the Result Token at the specified index.
|
|
func (r *Result) Value(idx int) interface{} {
|
|
return r.tokens[idx].Value
|
|
}
|