mirror of
https://github.com/kubernetes-sigs/descheduler.git
synced 2026-01-26 13:29:11 +01:00
429 lines
9.6 KiB
Go
429 lines
9.6 KiB
Go
// Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
|
|
// Use of this file is governed by the BSD 3-clause license that
|
|
// can be found in the LICENSE.txt file in the project root.
|
|
|
|
package antlr
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// atom, set, epsilon, action, predicate, rule transitions.
|
|
//
|
|
// <p>This is a one way link. It emanates from a state (usually via a list of
|
|
// transitions) and has a target state.</p>
|
|
//
|
|
// <p>Since we never have to change the ATN transitions once we construct it,
|
|
// the states. We'll use the term Edge for the DFA to distinguish them from
|
|
// ATN transitions.</p>
|
|
|
|
type Transition interface {
|
|
getTarget() ATNState
|
|
setTarget(ATNState)
|
|
getIsEpsilon() bool
|
|
getLabel() *IntervalSet
|
|
getSerializationType() int
|
|
Matches(int, int, int) bool
|
|
}
|
|
|
|
type BaseTransition struct {
|
|
target ATNState
|
|
isEpsilon bool
|
|
label int
|
|
intervalSet *IntervalSet
|
|
serializationType int
|
|
}
|
|
|
|
func NewBaseTransition(target ATNState) *BaseTransition {
|
|
|
|
if target == nil {
|
|
panic("target cannot be nil.")
|
|
}
|
|
|
|
t := new(BaseTransition)
|
|
|
|
t.target = target
|
|
// Are we epsilon, action, sempred?
|
|
t.isEpsilon = false
|
|
t.intervalSet = nil
|
|
|
|
return t
|
|
}
|
|
|
|
func (t *BaseTransition) getTarget() ATNState {
|
|
return t.target
|
|
}
|
|
|
|
func (t *BaseTransition) setTarget(s ATNState) {
|
|
t.target = s
|
|
}
|
|
|
|
func (t *BaseTransition) getIsEpsilon() bool {
|
|
return t.isEpsilon
|
|
}
|
|
|
|
func (t *BaseTransition) getLabel() *IntervalSet {
|
|
return t.intervalSet
|
|
}
|
|
|
|
func (t *BaseTransition) getSerializationType() int {
|
|
return t.serializationType
|
|
}
|
|
|
|
func (t *BaseTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
panic("Not implemented")
|
|
}
|
|
|
|
const (
|
|
TransitionEPSILON = 1
|
|
TransitionRANGE = 2
|
|
TransitionRULE = 3
|
|
TransitionPREDICATE = 4 // e.g., {isType(input.LT(1))}?
|
|
TransitionATOM = 5
|
|
TransitionACTION = 6
|
|
TransitionSET = 7 // ~(A|B) or ~atom, wildcard, which convert to next 2
|
|
TransitionNOTSET = 8
|
|
TransitionWILDCARD = 9
|
|
TransitionPRECEDENCE = 10
|
|
)
|
|
|
|
var TransitionserializationNames = []string{
|
|
"INVALID",
|
|
"EPSILON",
|
|
"RANGE",
|
|
"RULE",
|
|
"PREDICATE",
|
|
"ATOM",
|
|
"ACTION",
|
|
"SET",
|
|
"NOT_SET",
|
|
"WILDCARD",
|
|
"PRECEDENCE",
|
|
}
|
|
|
|
//var TransitionserializationTypes struct {
|
|
// EpsilonTransition int
|
|
// RangeTransition int
|
|
// RuleTransition int
|
|
// PredicateTransition int
|
|
// AtomTransition int
|
|
// ActionTransition int
|
|
// SetTransition int
|
|
// NotSetTransition int
|
|
// WildcardTransition int
|
|
// PrecedencePredicateTransition int
|
|
//}{
|
|
// TransitionEPSILON,
|
|
// TransitionRANGE,
|
|
// TransitionRULE,
|
|
// TransitionPREDICATE,
|
|
// TransitionATOM,
|
|
// TransitionACTION,
|
|
// TransitionSET,
|
|
// TransitionNOTSET,
|
|
// TransitionWILDCARD,
|
|
// TransitionPRECEDENCE
|
|
//}
|
|
|
|
// TODO: make all transitions sets? no, should remove set edges
|
|
type AtomTransition struct {
|
|
*BaseTransition
|
|
}
|
|
|
|
func NewAtomTransition(target ATNState, intervalSet int) *AtomTransition {
|
|
|
|
t := new(AtomTransition)
|
|
t.BaseTransition = NewBaseTransition(target)
|
|
|
|
t.label = intervalSet // The token type or character value or, signifies special intervalSet.
|
|
t.intervalSet = t.makeLabel()
|
|
t.serializationType = TransitionATOM
|
|
|
|
return t
|
|
}
|
|
|
|
func (t *AtomTransition) makeLabel() *IntervalSet {
|
|
s := NewIntervalSet()
|
|
s.addOne(t.label)
|
|
return s
|
|
}
|
|
|
|
func (t *AtomTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
return t.label == symbol
|
|
}
|
|
|
|
func (t *AtomTransition) String() string {
|
|
return strconv.Itoa(t.label)
|
|
}
|
|
|
|
type RuleTransition struct {
|
|
*BaseTransition
|
|
|
|
followState ATNState
|
|
ruleIndex, precedence int
|
|
}
|
|
|
|
func NewRuleTransition(ruleStart ATNState, ruleIndex, precedence int, followState ATNState) *RuleTransition {
|
|
|
|
t := new(RuleTransition)
|
|
t.BaseTransition = NewBaseTransition(ruleStart)
|
|
|
|
t.ruleIndex = ruleIndex
|
|
t.precedence = precedence
|
|
t.followState = followState
|
|
t.serializationType = TransitionRULE
|
|
t.isEpsilon = true
|
|
|
|
return t
|
|
}
|
|
|
|
func (t *RuleTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
return false
|
|
}
|
|
|
|
type EpsilonTransition struct {
|
|
*BaseTransition
|
|
|
|
outermostPrecedenceReturn int
|
|
}
|
|
|
|
func NewEpsilonTransition(target ATNState, outermostPrecedenceReturn int) *EpsilonTransition {
|
|
|
|
t := new(EpsilonTransition)
|
|
t.BaseTransition = NewBaseTransition(target)
|
|
|
|
t.serializationType = TransitionEPSILON
|
|
t.isEpsilon = true
|
|
t.outermostPrecedenceReturn = outermostPrecedenceReturn
|
|
return t
|
|
}
|
|
|
|
func (t *EpsilonTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
return false
|
|
}
|
|
|
|
func (t *EpsilonTransition) String() string {
|
|
return "epsilon"
|
|
}
|
|
|
|
type RangeTransition struct {
|
|
*BaseTransition
|
|
|
|
start, stop int
|
|
}
|
|
|
|
func NewRangeTransition(target ATNState, start, stop int) *RangeTransition {
|
|
|
|
t := new(RangeTransition)
|
|
t.BaseTransition = NewBaseTransition(target)
|
|
|
|
t.serializationType = TransitionRANGE
|
|
t.start = start
|
|
t.stop = stop
|
|
t.intervalSet = t.makeLabel()
|
|
return t
|
|
}
|
|
|
|
func (t *RangeTransition) makeLabel() *IntervalSet {
|
|
s := NewIntervalSet()
|
|
s.addRange(t.start, t.stop)
|
|
return s
|
|
}
|
|
|
|
func (t *RangeTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
return symbol >= t.start && symbol <= t.stop
|
|
}
|
|
|
|
func (t *RangeTransition) String() string {
|
|
var sb strings.Builder
|
|
sb.WriteByte('\'')
|
|
sb.WriteRune(rune(t.start))
|
|
sb.WriteString("'..'")
|
|
sb.WriteRune(rune(t.stop))
|
|
sb.WriteByte('\'')
|
|
return sb.String()
|
|
}
|
|
|
|
type AbstractPredicateTransition interface {
|
|
Transition
|
|
IAbstractPredicateTransitionFoo()
|
|
}
|
|
|
|
type BaseAbstractPredicateTransition struct {
|
|
*BaseTransition
|
|
}
|
|
|
|
func NewBasePredicateTransition(target ATNState) *BaseAbstractPredicateTransition {
|
|
|
|
t := new(BaseAbstractPredicateTransition)
|
|
t.BaseTransition = NewBaseTransition(target)
|
|
|
|
return t
|
|
}
|
|
|
|
func (a *BaseAbstractPredicateTransition) IAbstractPredicateTransitionFoo() {}
|
|
|
|
type PredicateTransition struct {
|
|
*BaseAbstractPredicateTransition
|
|
|
|
isCtxDependent bool
|
|
ruleIndex, predIndex int
|
|
}
|
|
|
|
func NewPredicateTransition(target ATNState, ruleIndex, predIndex int, isCtxDependent bool) *PredicateTransition {
|
|
|
|
t := new(PredicateTransition)
|
|
t.BaseAbstractPredicateTransition = NewBasePredicateTransition(target)
|
|
|
|
t.serializationType = TransitionPREDICATE
|
|
t.ruleIndex = ruleIndex
|
|
t.predIndex = predIndex
|
|
t.isCtxDependent = isCtxDependent // e.g., $i ref in pred
|
|
t.isEpsilon = true
|
|
return t
|
|
}
|
|
|
|
func (t *PredicateTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
return false
|
|
}
|
|
|
|
func (t *PredicateTransition) getPredicate() *Predicate {
|
|
return NewPredicate(t.ruleIndex, t.predIndex, t.isCtxDependent)
|
|
}
|
|
|
|
func (t *PredicateTransition) String() string {
|
|
return "pred_" + strconv.Itoa(t.ruleIndex) + ":" + strconv.Itoa(t.predIndex)
|
|
}
|
|
|
|
type ActionTransition struct {
|
|
*BaseTransition
|
|
|
|
isCtxDependent bool
|
|
ruleIndex, actionIndex, predIndex int
|
|
}
|
|
|
|
func NewActionTransition(target ATNState, ruleIndex, actionIndex int, isCtxDependent bool) *ActionTransition {
|
|
|
|
t := new(ActionTransition)
|
|
t.BaseTransition = NewBaseTransition(target)
|
|
|
|
t.serializationType = TransitionACTION
|
|
t.ruleIndex = ruleIndex
|
|
t.actionIndex = actionIndex
|
|
t.isCtxDependent = isCtxDependent // e.g., $i ref in pred
|
|
t.isEpsilon = true
|
|
return t
|
|
}
|
|
|
|
func (t *ActionTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
return false
|
|
}
|
|
|
|
func (t *ActionTransition) String() string {
|
|
return "action_" + strconv.Itoa(t.ruleIndex) + ":" + strconv.Itoa(t.actionIndex)
|
|
}
|
|
|
|
type SetTransition struct {
|
|
*BaseTransition
|
|
}
|
|
|
|
func NewSetTransition(target ATNState, set *IntervalSet) *SetTransition {
|
|
|
|
t := new(SetTransition)
|
|
t.BaseTransition = NewBaseTransition(target)
|
|
|
|
t.serializationType = TransitionSET
|
|
if set != nil {
|
|
t.intervalSet = set
|
|
} else {
|
|
t.intervalSet = NewIntervalSet()
|
|
t.intervalSet.addOne(TokenInvalidType)
|
|
}
|
|
|
|
return t
|
|
}
|
|
|
|
func (t *SetTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
return t.intervalSet.contains(symbol)
|
|
}
|
|
|
|
func (t *SetTransition) String() string {
|
|
return t.intervalSet.String()
|
|
}
|
|
|
|
type NotSetTransition struct {
|
|
*SetTransition
|
|
}
|
|
|
|
func NewNotSetTransition(target ATNState, set *IntervalSet) *NotSetTransition {
|
|
|
|
t := new(NotSetTransition)
|
|
|
|
t.SetTransition = NewSetTransition(target, set)
|
|
|
|
t.serializationType = TransitionNOTSET
|
|
|
|
return t
|
|
}
|
|
|
|
func (t *NotSetTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
return symbol >= minVocabSymbol && symbol <= maxVocabSymbol && !t.intervalSet.contains(symbol)
|
|
}
|
|
|
|
func (t *NotSetTransition) String() string {
|
|
return "~" + t.intervalSet.String()
|
|
}
|
|
|
|
type WildcardTransition struct {
|
|
*BaseTransition
|
|
}
|
|
|
|
func NewWildcardTransition(target ATNState) *WildcardTransition {
|
|
|
|
t := new(WildcardTransition)
|
|
t.BaseTransition = NewBaseTransition(target)
|
|
|
|
t.serializationType = TransitionWILDCARD
|
|
return t
|
|
}
|
|
|
|
func (t *WildcardTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
return symbol >= minVocabSymbol && symbol <= maxVocabSymbol
|
|
}
|
|
|
|
func (t *WildcardTransition) String() string {
|
|
return "."
|
|
}
|
|
|
|
type PrecedencePredicateTransition struct {
|
|
*BaseAbstractPredicateTransition
|
|
|
|
precedence int
|
|
}
|
|
|
|
func NewPrecedencePredicateTransition(target ATNState, precedence int) *PrecedencePredicateTransition {
|
|
|
|
t := new(PrecedencePredicateTransition)
|
|
t.BaseAbstractPredicateTransition = NewBasePredicateTransition(target)
|
|
|
|
t.serializationType = TransitionPRECEDENCE
|
|
t.precedence = precedence
|
|
t.isEpsilon = true
|
|
|
|
return t
|
|
}
|
|
|
|
func (t *PrecedencePredicateTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool {
|
|
return false
|
|
}
|
|
|
|
func (t *PrecedencePredicateTransition) getPredicate() *PrecedencePredicate {
|
|
return NewPrecedencePredicate(t.precedence)
|
|
}
|
|
|
|
func (t *PrecedencePredicateTransition) String() string {
|
|
return fmt.Sprint(t.precedence) + " >= _p"
|
|
}
|