b/gigaparsec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Don't require so much Pos() when making messages

Browse Source
This commit is contained in:
b
2026-08-21 22:36:36 -06:00
parent cc25ac923f
commit 17b2a0eee5
9 changed files with 81 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files
gigaparsec.go
+51 -39
View File
@@ -59,12 +59,24 @@ func (r Result[In, Out]) Message() Message {
return r.message
}
func MakeMessage(pos uint64, got string, expected ...string) Message {
return Message{
pos: pos,
got: got,
expected: expected,
type ReaderAt[T any] interface {
ReadAt(p []T, off int64) (n int, err error)
}
type SliceReaderAt[T any] []T
func (s SliceReaderAt[T]) ReadAt(dst []T, off int64) (n int, err error) {
if off < 0 {
return 0, errors.New("SliceReaderAt.ReadAt: negative offset")
}
if off >= int64(len(s)) {
return 0, io.EOF
}
n = copy(dst, s[off:])
if n < len(dst) {
err = io.EOF
}
return n, err
}
type Message struct {
@@ -107,36 +119,26 @@ func (m Message) String() string {
return s
}
func MakeMessage(pos uint64, got string, expected ...string) Message {
return Message{
pos: pos,
got: got,
expected: expected,
}
}
func MessageOK(pos uint64) Message { return Message{pos: pos} }
func MessageEnd(pos uint64, expected ...string) Message {
return Message{pos: pos, got: "end of input", expected: expected}
}
type ReaderAt[T any] interface {
ReadAt(p []T, off int64) (n int, err error)
}
type SliceReaderAt[T any] []T
func (s SliceReaderAt[T]) ReadAt(dst []T, off int64) (n int, err error) {
if off < 0 {
return 0, errors.New("SliceReaderAt.ReadAt: negative offset")
}
if off >= int64(len(s)) {
return 0, io.EOF
}
n = copy(dst, s[off:])
if n < len(dst) {
err = io.EOF
}
return n, err
}
// MakeState creates a new State
func MakeState[In any](r ReaderAt[In]) State[In] {
return State[In]{r: r}
}
// State represents a position in an input source.
type State[In any] struct {
r ReaderAt[In]
pos uint64
@@ -176,6 +178,16 @@ func (s State[In]) At(pos uint64) State[In] {
return State[In]{r: s.r, pos: pos}
}
func (s State[In]) Message(got string, expected ...string) Message {
return MakeMessage(s.pos, got, expected...)
}
func (s State[In]) MessageOK() Message { return MessageOK(s.pos) }
func (s State[in]) MessageEnd(expected ...string) Message {
return MessageEnd(s.pos, expected...)
}
type Parser[In, Out any] func(State[In]) (Result[In, Out], error)
// Label creates a parser identical to p, except that a failed result will
@@ -238,7 +250,7 @@ func (pe ParseError) Error() string {
// Return creates a parser that always succeeds and returns value without consuming any input.
func Return[In, Out any](value Out) Parser[In, Out] {
return func(state State[In]) (Result[In, Out], error) {
return Succeed(false, value, state, MessageOK(state.Pos())), nil
return Succeed(false, value, state, state.MessageOK()), nil
}
}
@@ -249,7 +261,7 @@ func Satisfy[T any](pred func(T) bool) Parser[T, T] {
token := make([]T, 1)
n, next, err := state.Read(token)
if errors.Is(err, io.EOF) {
return Fail[T, T](false, MessageEnd(state.Pos())), nil
return Fail[T, T](false, state.MessageEnd()), nil
}
if err != nil {
return Result[T, T]{}, err
@@ -258,9 +270,9 @@ func Satisfy[T any](pred func(T) bool) Parser[T, T] {
panic(fmt.Sprintf("expected 1 element from Read, but got %d", n))
}
if pred(token[0]) {
return Succeed(true, token[0], next, MessageOK(state.Pos())), nil
return Succeed(true, token[0], next, state.MessageOK()), nil
}
return Fail[T, T](false, MakeMessage(state.Pos(), fmt.Sprint(token))), nil
return Fail[T, T](false, state.Message(fmt.Sprint(token))), nil
}
}
@@ -272,15 +284,15 @@ func Match[T comparable](x T) Parser[T, T] {
token := make([]T, 1)
_, next, err := state.Read(token)
if errors.Is(err, io.EOF) {
return Fail[T, T](false, MessageEnd(state.Pos())), nil
return Fail[T, T](false, state.MessageEnd()), nil
}
if err != nil {
return Result[T, T]{}, err
}
if token[0] == x {
return Succeed(true, token[0], next, MessageOK(state.Pos())), nil
return Succeed(true, token[0], next, state.MessageOK()), nil
}
return Fail[T, T](false, MakeMessage(state.Pos(), fmt.Sprint(token), expected)), nil
return Fail[T, T](false, state.Message(fmt.Sprint(token), expected)), nil
}
}
@@ -292,15 +304,15 @@ func MatchSlice[T comparable](s []T) Parser[T, []T] {
token := make([]T, len(s))
_, next, err := state.Read(token)
if errors.Is(err, io.EOF) {
return Fail[T, []T](false, MessageEnd(state.Pos())), nil
return Fail[T, []T](false, state.MessageEnd()), nil
}
if err != nil {
return Result[T, []T]{}, err
}
if !slices.Equal(s, token) {
return Fail[T, []T](false, MakeMessage(state.Pos(), fmt.Sprint(token), expected)), nil
return Fail[T, []T](false, state.Message(fmt.Sprint(token), expected)), nil
}
return Succeed(true, token, next, MessageOK(state.Pos())), nil
return Succeed(true, token, next, state.MessageOK()), nil
}
}
@@ -337,7 +349,7 @@ func Choose[In, Out any](p Parser[In, Out], ps ...Parser[In, Out]) Parser[In, Ou
got = qMsg.got
}
}
msg := MakeMessage(input.Pos(), got, slices.Concat(expecteds...)...)
msg := input.Message(got, slices.Concat(expecteds...)...)
if failed {
return Fail[In, Out](false, msg), nil
}
@@ -367,12 +379,12 @@ func Try[In, Out any](p Parser[In, Out]) Parser[In, Out] {
func end[In any](s State[In]) (Result[In, struct{}], error) {
_, _, err := s.Read([]In{})
if errors.Is(err, io.EOF) {
return Succeed(true, struct{}{}, s, MessageOK(s.Pos())), nil
return Succeed(true, struct{}{}, s, s.MessageOK()), nil
}
if err != nil {
return Result[In, struct{}]{}, fmt.Errorf("End: unexpected error: %w", err)
}
return Fail[In, struct{}](false, MakeMessage(s.Pos(), "", "end of input")), nil
return Fail[In, struct{}](false, s.Message("", "end of input")), nil
}
// End creates a parser that succeeds at the end of the input and fails otherwise.
@@ -407,7 +419,7 @@ func Repeat[In, Out any](minCount int, p Parser[In, Out]) Parser[In, []Out] {
success, value, nextState := result.Status()
if !success {
if len(values) >= minCount {
return Succeed(consumed, values, currState, MessageOK(state.Pos())), nil
return Succeed(consumed, values, currState, state.MessageOK()), nil
}
return Fail[In, []Out](consumed, result.Message()), nil
}