43 lines
1.4 KiB
Go
43 lines
1.4 KiB
Go
package parsekit
|
|
|
|
// RouteTo tells the parser what StateHandler function to invoke
|
|
// in the next parsing cycle.
|
|
func (p *P) RouteTo(state StateHandler) *routeFollowupAction {
|
|
p.nextState = state
|
|
return &routeFollowupAction{chainAction: chainAction{p, true}}
|
|
}
|
|
|
|
// RouteRepeat indicates that on the next parsing cycle, the current
|
|
// StateHandler must be reinvoked.
|
|
func (p *P) RouteRepeat() *chainAction {
|
|
p.RouteTo(p.state)
|
|
return &chainAction{nil, true}
|
|
}
|
|
|
|
// RouteReturn tells the parser that on the next cycle the last
|
|
// StateHandler that was pushed on the route stack must be invoked.
|
|
//
|
|
// Using this method is optional. When implementating a StateHandler that
|
|
// is used as a sort of subroutine (using constructions like
|
|
// p.RouteTo(subroutine).ThenReturnHere()), you can refrain from
|
|
// providing an explicit routing decision from that handler. The parser will
|
|
// automatically assume a RouteReturn() in that case.
|
|
func (p *P) RouteReturn() *chainAction {
|
|
p.nextState = p.popRoute()
|
|
return &chainAction{nil, true}
|
|
}
|
|
|
|
// pushRoute adds the StateHandler to the route stack.
|
|
// This is used for implementing nested parsing.
|
|
func (p *P) pushRoute(state StateHandler) {
|
|
p.routeStack = append(p.routeStack, state)
|
|
}
|
|
|
|
// popRoute pops the last pushed StateHandler from the route stack.
|
|
func (p *P) popRoute() StateHandler {
|
|
last := len(p.routeStack) - 1
|
|
head, tail := p.routeStack[:last], p.routeStack[last]
|
|
p.routeStack = head
|
|
return tail
|
|
}
|