104 lines
3 KiB
Go
104 lines
3 KiB
Go
package participle
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/alecthomas/participle/v2/lexer"
|
|
)
|
|
|
|
// Error represents an error while parsing.
|
|
//
|
|
// The format of an Error is in the form "[<filename>:][<line>:<pos>:] <message>".
|
|
//
|
|
// The error will contain positional information if available.
|
|
type Error interface {
|
|
error
|
|
// Unadorned message.
|
|
Message() string
|
|
// Closest position to error location.
|
|
Position() lexer.Position
|
|
}
|
|
|
|
// FormatError formats an error in the form "[<filename>:][<line>:<pos>:] <message>"
|
|
func FormatError(err Error) string {
|
|
msg := ""
|
|
pos := err.Position()
|
|
if pos.Filename != "" {
|
|
msg += pos.Filename + ":"
|
|
}
|
|
if pos.Line != 0 || pos.Column != 0 {
|
|
msg += fmt.Sprintf("%d:%d:", pos.Line, pos.Column)
|
|
}
|
|
if msg != "" {
|
|
msg += " " + err.Message()
|
|
} else {
|
|
msg = err.Message()
|
|
}
|
|
return msg
|
|
}
|
|
|
|
// UnexpectedTokenError is returned by Parse when an unexpected token is encountered.
|
|
//
|
|
// This is useful for composing parsers in order to detect when a sub-parser has terminated.
|
|
type UnexpectedTokenError struct {
|
|
Unexpected lexer.Token
|
|
at node
|
|
}
|
|
|
|
func (u UnexpectedTokenError) Error() string { return FormatError(u) }
|
|
|
|
func (u UnexpectedTokenError) Message() string { // nolint: golint
|
|
var expected string
|
|
if u.at != nil {
|
|
expected = fmt.Sprintf(" (expected %s)", u.at)
|
|
}
|
|
return fmt.Sprintf("unexpected token %q%s", u.Unexpected, expected)
|
|
}
|
|
func (u UnexpectedTokenError) Position() lexer.Position { return u.Unexpected.Pos } // nolint: golint
|
|
|
|
type parseError struct {
|
|
Msg string
|
|
Pos lexer.Position
|
|
}
|
|
|
|
func (p *parseError) Error() string { return FormatError(p) }
|
|
func (p *parseError) Message() string { return p.Msg }
|
|
func (p *parseError) Position() lexer.Position { return p.Pos }
|
|
|
|
// Errorf creats a new Error at the given position.
|
|
func Errorf(pos lexer.Position, format string, args ...interface{}) Error {
|
|
return &parseError{Msg: fmt.Sprintf(format, args...), Pos: pos}
|
|
}
|
|
|
|
type wrappingParseError struct {
|
|
err error
|
|
parseError
|
|
}
|
|
|
|
func (w *wrappingParseError) Unwrap() error { return w.err }
|
|
|
|
// Wrapf attempts to wrap an existing error in a new message.
|
|
//
|
|
// If "err" is a participle.Error, its positional information will be uesd.
|
|
//
|
|
// The returned error implements the Unwrap() method supported by the errors package.
|
|
func Wrapf(pos lexer.Position, err error, format string, args ...interface{}) Error {
|
|
var msg string
|
|
if perr, ok := err.(Error); ok {
|
|
pos = perr.Position()
|
|
msg = fmt.Sprintf("%s: %s", fmt.Sprintf(format, args...), perr.Message())
|
|
} else {
|
|
msg = fmt.Sprintf("%s: %s", fmt.Sprintf(format, args...), err.Error())
|
|
}
|
|
return &wrappingParseError{err: err, parseError: parseError{Msg: msg, Pos: pos}}
|
|
}
|
|
|
|
// AnnotateError wraps an existing error with a position.
|
|
//
|
|
// If the existing error is a lexer.Error or participle.Error it will be returned unmodified.
|
|
func AnnotateError(pos lexer.Position, err error) error {
|
|
if perr, ok := err.(Error); ok {
|
|
return perr
|
|
}
|
|
return &wrappingParseError{err: err, parseError: parseError{Msg: err.Error(), Pos: pos}}
|
|
}
|