54 lines
2.1 KiB
Go
54 lines
2.1 KiB
Go
package tokenize
|
|
|
|
// Handler is the function type that is involved in turning a low level
|
|
// stream of UTF8 runes into lexical tokens. Its purpose is to check if input
|
|
// data matches some kind of pattern and to report back the results.
|
|
//
|
|
// A Handler function gets an API as its input and returns a boolean to
|
|
// indicate whether or not it found a match on the input. The API is used
|
|
// for retrieving input data to match against and for reporting back results.
|
|
type Handler func(tokenAPI *API) bool
|
|
|
|
// Match is syntactic sugar that allows you to write a construction like
|
|
// NewTokenizer(handler).Execute(input) as handler.Match(input).
|
|
func (handler Handler) Match(input interface{}) (*Result, error) {
|
|
tokenizer := New(handler)
|
|
return tokenizer(input)
|
|
}
|
|
|
|
// Or is syntactic sugar that allows you to write a construction like
|
|
// MatchAny(tokenHandler1, tokenHandler2) as tokenHandler1.Or(tokenHandler2).
|
|
func (handler Handler) Or(otherHandler Handler) Handler {
|
|
return MatchAny(handler, otherHandler)
|
|
}
|
|
|
|
// Times is syntactic sugar that allows you to write a construction like
|
|
// MatchRep(3, handler) as handler.Times(3).
|
|
func (handler Handler) Times(n int) Handler {
|
|
return MatchRep(n, handler)
|
|
}
|
|
|
|
// Then is syntactic sugar that allows you to write a construction like
|
|
// MatchSeq(handler1, handler2, handler3) as handler1.Then(handler2).Then(handler3).
|
|
func (handler Handler) Then(otherHandler Handler) Handler {
|
|
return MatchSeq(handler, otherHandler)
|
|
}
|
|
|
|
// SeparatedBy is syntactic sugar that allows you to write a construction like
|
|
// MatchSeparated(handler, separator) as handler.SeparatedBy(separator).
|
|
func (handler Handler) SeparatedBy(separator Handler) Handler {
|
|
return MatchSeparated(separator, handler)
|
|
}
|
|
|
|
// Optional is syntactic sugar that allows you to write a construction like
|
|
// MatchOptional(handler) as handler.Optional().
|
|
func (handler Handler) Optional() Handler {
|
|
return MatchOptional(handler)
|
|
}
|
|
|
|
// Except is syntactic sugar that allows you to write a construction like
|
|
// MatchExcept(handler) as handler.Optional().
|
|
func (handler Handler) Except(exceptHandler Handler) Handler {
|
|
return MatchExcept(handler, exceptHandler)
|
|
}
|