Rockingcool
/
kleingrep
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Renamed 'State' to 'state' to avoid exposing the insides of the engine

Browse Source
master
Aadhavan Srinivasan 3 days ago
parent 429d286439
commit d81b2ddaaa
1 changed files with 48 additions and 48 deletions
Show Stats Download Patch File Download Diff File

96
regex/nfa.go
Unescape Escape View File

@ -22,18 +22,18 @@ const (
alwaysTrueAssert // An assertion that is always true
)
type State struct {
type state struct {
content stateContents // Contents of current state
isEmpty bool // If it is empty - Union operator and Kleene star states will be empty
isLast bool // If it is the last state (acept state)
output []*State // The outputs of the current state ie. the 'outward arrows'. A union operator state will have more than one of these.
transitions map[int][]*State // Transitions to different states (maps a character (int representation) to a _list of states. This is useful if one character can lead multiple states eg. ab|aa)
output []*state // The outputs of the current state ie. the 'outward arrows'. A union operator state will have more than one of these.
transitions map[int][]*state // Transitions to different states (maps a character (int representation) to a _list of states. This is useful if one character can lead multiple states eg. ab|aa)
isKleene bool // Identifies whether current node is a 0-state representing Kleene star
assert assertType // Type of assertion of current node - NONE means that the node doesn't assert anything
allChars bool // Whether or not the state represents all characters (eg. a 'dot' metacharacter). A 'dot' node doesn't store any contents directly, as it would take up too much space
except []rune // Only valid if allChars is true - match all characters _except_ the ones in this block. Useful for inverting character classes.
lookaroundRegex string // Only for lookaround states - Contents of the regex that the lookaround state holds
lookaroundNFA *State // Holds the NFA of the lookaroundRegex - if it exists
lookaroundNFA *state // Holds the NFA of the lookaroundRegex - if it exists
lookaroundNumCaptureGroups int // Number of capturing groups in lookaround regex if current node is a lookaround
groupBegin bool // Whether or not the node starts a capturing group
groupEnd bool // Whether or not the node ends a capturing group
@ -44,14 +44,14 @@ type State struct {
}
// Clones the NFA starting from the given state.
func cloneState(start *State) *State {
return cloneStateHelper(start, make(map[*State]*State))
func cloneState(start *state) *state {
return cloneStateHelper(start, make(map[*state]*state))
}
// Helper function for clone. The map is used to keep track of which states have
// already been copied, and which ones haven't.
// This function was created using output from Llama3.1:405B.
func cloneStateHelper(stateToClone *State, cloneMap map[*State]*State) *State {
func cloneStateHelper(stateToClone *state, cloneMap map[*state]*state) *state {
// Base case - if the clone exists in our map, return it.
if clone, exists := cloneMap[stateToClone]; exists {
return clone
@ -61,12 +61,12 @@ func cloneStateHelper(stateToClone *State, cloneMap map[*State]*State) *State {
}
// Recursive case - if the clone doesn't exist, create it, add it to the map,
// and recursively call for each of the transition states.
clone := &State{
clone := &state{
content: append([]int{}, stateToClone.content...),
isEmpty: stateToClone.isEmpty,
isLast: stateToClone.isLast,
output: make([]*State, len(stateToClone.output)),
transitions: make(map[int][]*State),
output: make([]*state, len(stateToClone.output)),
transitions: make(map[int][]*state),
isKleene: stateToClone.isKleene,
assert: stateToClone.assert,
zeroMatchFound: stateToClone.zeroMatchFound,
@ -86,7 +86,7 @@ func cloneStateHelper(stateToClone *State, cloneMap map[*State]*State) *State {
}
}
for k, v := range stateToClone.transitions {
clone.transitions[k] = make([]*State, len(v))
clone.transitions[k] = make([]*state, len(v))
for i, s := range v {
if s == stateToClone {
clone.transitions[k][i] = clone
@ -104,7 +104,7 @@ func cloneStateHelper(stateToClone *State, cloneMap map[*State]*State) *State {
// Checks if the given state's assertion is true. Returns true if the given
// state doesn't have an assertion.
func (s State) checkAssertion(str []rune, idx int) bool {
func (s state) checkAssertion(str []rune, idx int) bool {
if s.assert == alwaysTrueAssert {
return true
}
@ -171,7 +171,7 @@ func (s State) checkAssertion(str []rune, idx int) bool {
}
// Returns true if the contents of 's' contain the value at the given index of the given string
func (s State) contentContains(str []rune, idx int) bool {
func (s state) contentContains(str []rune, idx int) bool {
if s.assert != noneAssert {
return s.checkAssertion(str, idx)
}
@ -182,19 +182,19 @@ func (s State) contentContains(str []rune, idx int) bool {
return slices.Contains(s.content, int(str[idx]))
}
func (s State) isLookaround() bool {
func (s state) isLookaround() bool {
return s.assert == plaAssert || s.assert == plbAssert || s.assert == nlaAssert || s.assert == nlbAssert
}
// Returns the matches for the character at the given index of the given string.
// Also returns the number of matches. Returns -1 if an assertion failed.
func (s State) matchesFor(str []rune, idx int) ([]*State, int) {
func (s state) matchesFor(str []rune, idx int) ([]*state, int) {
// Assertions can be viewed as 'checks'. If the check fails, we return
// an empty array and 0.
// If it passes, we treat it like any other state, and return all the transitions.
if s.assert != noneAssert {
if s.checkAssertion(str, idx) == false {
return make([]*State, 0), -1
return make([]*state, 0), -1
}
}
listTransitions := s.transitions[int(str[idx])]
@ -211,39 +211,39 @@ func (s State) matchesFor(str []rune, idx int) ([]*State, int) {
}
// verifyLastStatesHelper performs the depth-first recursion needed for verifyLastStates
func verifyLastStatesHelper(state *State, visited map[*State]bool) {
if len(state.transitions) == 0 {
state.isLast = true
func verifyLastStatesHelper(st *state, visited map[*state]bool) {
if len(st.transitions) == 0 {
st.isLast = true
return
}
// if len(state.transitions) == 1 && len(state.transitions[state.content]) == 1 && state.transitions[state.content][0] == state { // Eg. a*
if len(state.transitions) == 1 { // Eg. a*
if len(st.transitions) == 1 { // Eg. a*
var moreThanOneTrans bool // Dummy variable, check if all the transitions for the current's state's contents have a length of one
for _, c := range state.content {
if len(state.transitions[c]) != 1 || state.transitions[c][0] != state {
for _, c := range st.content {
if len(st.transitions[c]) != 1 || st.transitions[c][0] != st {
moreThanOneTrans = true
}
}
state.isLast = !moreThanOneTrans
st.isLast = !moreThanOneTrans
}
if state.isKleene { // A State representing a Kleene Star has transitions going out, which loop back to it. If all those transitions point to the same (single) state, then it must be a last state
transitionDests := make([]*State, 0)
for _, v := range state.transitions {
if st.isKleene { // A State representing a Kleene Star has transitions going out, which loop back to it. If all those transitions point to the same (single) state, then it must be a last state
transitionDests := make([]*state, 0)
for _, v := range st.transitions {
transitionDests = append(transitionDests, v...)
}
if allEqual(transitionDests...) {
state.isLast = true
st.isLast = true
return
}
}
if visited[state] == true {
if visited[st] == true {
return
}
visited[state] = true
for _, states := range state.transitions {
visited[st] = true
for _, states := range st.transitions {
for i := range states {
if states[i] != state {
if states[i] != st {
verifyLastStatesHelper(states[i], visited)
}
}
@ -251,12 +251,12 @@ func verifyLastStatesHelper(state *State, visited map[*State]bool) {
}
// verifyLastStates enables the 'isLast' flag for the leaf nodes (last states)
func verifyLastStates(start []*State) {
verifyLastStatesHelper(start[0], make(map[*State]bool))
func verifyLastStates(start []*state) {
verifyLastStatesHelper(start[0], make(map[*state]bool))
}
// Concatenates s1 and s2, returns the start of the concatenation.
func concatenate(s1 *State, s2 *State) *State {
func concatenate(s1 *state, s2 *state) *state {
if s1 == nil {
return s2
}
@ -269,13 +269,13 @@ func concatenate(s1 *State, s2 *State) *State {
return s1
}
func kleene(s1 State) (*State, error) {
func kleene(s1 state) (*state, error) {
if s1.isEmpty && s1.assert != noneAssert {
return nil, fmt.Errorf("previous token is not quantifiable")
}
toReturn := &State{}
toReturn.transitions = make(map[int][]*State)
toReturn := &state{}
toReturn.transitions = make(map[int][]*state)
toReturn.content = newContents(EPSILON)
toReturn.isEmpty = true
toReturn.isKleene = true
@ -291,9 +291,9 @@ func kleene(s1 State) (*State, error) {
return toReturn, nil
}
func alternate(s1 *State, s2 *State) *State {
toReturn := &State{}
toReturn.transitions = make(map[int][]*State)
func alternate(s1 *state, s2 *state) *state {
toReturn := &state{}
toReturn.transitions = make(map[int][]*state)
toReturn.output = append(toReturn.output, s1.output...)
toReturn.output = append(toReturn.output, s2.output...)
// Unique append is used here (and elsewhere) to ensure that,
@ -313,9 +313,9 @@ func alternate(s1 *State, s2 *State) *State {
return toReturn
}
func question(s1 *State) *State { // Use the fact that ab? == a(b|)
s2 := &State{}
s2.transitions = make(map[int][]*State)
func question(s1 *state) *state { // Use the fact that ab? == a(b|)
s2 := &state{}
s2.transitions = make(map[int][]*state)
s2.content = newContents(EPSILON)
s2.output = append(s2.output, s2)
s2.isEmpty = true
@ -324,10 +324,10 @@ func question(s1 *State) *State { // Use the fact that ab? == a(b|)
}
// Creates and returns a new state with the 'default' values.
func newState() State {
ret := State{
output: make([]*State, 0),
transitions: make(map[int][]*State),
func newState() state {
ret := state{
output: make([]*state, 0),
transitions: make(map[int][]*state),
assert: noneAssert,
except: append([]rune{}, 0),
lookaroundRegex: "",
@ -339,7 +339,7 @@ func newState() State {
}
// Creates and returns a state that _always_ has a zero-length match.
func zeroLengthMatchState() State {
func zeroLengthMatchState() state {
start := newState()
start.content = newContents(EPSILON)
start.isEmpty = true

Write Preview
Loading…
Cancel
Save