109 lines
3.2 KiB
Go
109 lines
3.2 KiB
Go
package parsekit
|
|
|
|
import (
|
|
"fmt"
|
|
)
|
|
|
|
// ItemType represents the type of a parser Item.
|
|
type ItemType int
|
|
|
|
// ItemEOF is a built-in parser item type that is used for flagging that the
|
|
// end of the input was reached.
|
|
const ItemEOF ItemType = -1
|
|
|
|
// ItemError is a built-in parser item type that is used for flagging that
|
|
// an error has occurred during parsing.
|
|
const ItemError ItemType = -2
|
|
|
|
// MatchedItem is a built-in parser item type that is used for indicating a
|
|
// successful match when using a parser that is based on a Matcher.
|
|
const MatchedItem ItemType = -3
|
|
|
|
// Item represents an item that can be emitted from the parser.
|
|
type Item struct {
|
|
Type ItemType
|
|
Value string
|
|
}
|
|
|
|
// Emit passes a Parser item to the client, including the provided string.
|
|
func (p *P) Emit(t ItemType, v string) {
|
|
p.items <- Item{t, v}
|
|
p.buffer.reset()
|
|
}
|
|
|
|
// EmitLiteral passes a Parser item to the client, including accumulated
|
|
// string buffer data as a literal string.
|
|
func (p *P) EmitLiteral(t ItemType) {
|
|
p.Emit(t, p.buffer.asLiteralString())
|
|
}
|
|
|
|
// EmitInterpreted passes a Parser item to the client, including accumulated
|
|
// string buffer data a Go double quoted interpreted string (handling escape
|
|
// codes like \n, \t, \uXXXX, etc.)
|
|
// This method returns a boolean value, indicating whether or not the string
|
|
// interpretation was successful. On invalid string data, an error will
|
|
// automatically be emitted and false will be returned.
|
|
func (p *P) EmitInterpreted(t ItemType) bool {
|
|
s, err := p.buffer.asInterpretedString()
|
|
if err != nil {
|
|
p.EmitError(
|
|
"invalid string: %s (%s, forgot to escape a double quote or backslash maybe?)",
|
|
p.buffer.asLiteralString(), err)
|
|
return false
|
|
}
|
|
p.Emit(t, s)
|
|
return true
|
|
}
|
|
|
|
// Error is used as the error type when parsing errors occur.
|
|
// The error includes some extra meta information to allow for useful
|
|
// error messages to the user.
|
|
type Error struct {
|
|
Message string
|
|
Line int
|
|
Column int
|
|
}
|
|
|
|
func (err *Error) Error() string {
|
|
if err == nil {
|
|
panic("internal parser error: Error() method called on the parser, but no error was set")
|
|
}
|
|
return err.Message
|
|
}
|
|
|
|
// ErrorFull returns the current error message, including information about
|
|
// the position in the input where the error occurred.
|
|
func (err *Error) ErrorFull() string {
|
|
message := err.Error()
|
|
return fmt.Sprintf("%s after line %d, column %d", message, err.Line, err.Column)
|
|
}
|
|
|
|
// EmitError emits a Parser error item to the client.
|
|
func (p *P) EmitError(format string, args ...interface{}) {
|
|
message := fmt.Sprintf(format, args...)
|
|
p.Emit(ItemError, message)
|
|
}
|
|
|
|
// UnexpectedInput is used by a StateHandler function to emit an error item
|
|
// that tells the client that an unexpected rune was encountered in the input.
|
|
func (p *P) UnexpectedInput() {
|
|
r, _, ok := p.peek(0)
|
|
switch {
|
|
case ok:
|
|
p.EmitError("unexpected character %q%s", r, fmtExpects(p))
|
|
case r == EOF:
|
|
p.EmitError("unexpected end of file%s", fmtExpects(p))
|
|
case r == INVALID:
|
|
p.EmitError("invalid UTF8 character in input%s", fmtExpects(p))
|
|
default:
|
|
panic("parsekit bug: Unhandled output from peek()")
|
|
}
|
|
}
|
|
|
|
func fmtExpects(p *P) string {
|
|
if p.expecting == "" {
|
|
return ""
|
|
}
|
|
return fmt.Sprintf(" (expected %s)", p.expecting)
|
|
}
|