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

Updated assertion constants so that they aren't exported

Browse Source
This commit is contained in:
Aadhavan Srinivasan
2025-01-30 10:18:18 -05:00
parent 7e6377a4c4
commit 289bba35e2
3 changed files with 39 additions and 39 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
regex/compile.go
View File

@@ -871,30 +871,30 @@ func thompson(re []postfixNode) (Reg, error) {
if c.lookaroundDir == 0 || c.lookaroundSign == 0 {
switch c.contents[0] {
case '^':
state.assert = SOS
state.assert = sosAssert
case '$':
state.assert = EOS
state.assert = eosAssert
case 'b':
state.assert = WBOUND
state.assert = wboundAssert
case 'B':
state.assert = NONWBOUND
state.assert = nonwboundAssert
}
} else { // Lookaround
state.lookaroundRegex = string(c.contents)
if c.lookaroundDir == lookahead {
if c.lookaroundSign == positive {
state.assert = PLA
state.assert = plaAssert
}
if c.lookaroundSign == negative {
state.assert = NLA
state.assert = nlaAssert
}
}
if c.lookaroundDir == lookbehind {
if c.lookaroundSign == positive {
state.assert = PLB
state.assert = plbAssert
}
if c.lookaroundSign == negative {
state.assert = NLB
state.assert = nlbAssert
}
}
tmpRe, err := shuntingYard(state.lookaroundRegex)
@@ -919,7 +919,7 @@ func thompson(re []postfixNode) (Reg, error) {
}
if c.nodetype == lparenNode || c.nodetype == rparenNode {
s := &State{}
s.assert = NONE
s.assert = noneAssert
s.content = newContents(EPSILON)
s.isEmpty = true
s.output = make([]*State, 0)

8
regex/matching.go
View File

@@ -107,7 +107,7 @@ func zeroMatchPossible(str []rune, idx int, numGroups int, states ...*State) boo
}
}
for _, state := range tempstates {
if state.isEmpty && (state.assert == NONE || state.checkAssertion(str, idx)) && state.isLast {
if state.isEmpty && (state.assert == noneAssert || state.checkAssertion(str, idx)) && state.isLast {
return true
}
}
@@ -228,7 +228,7 @@ func findAllMatchesHelper(start *State, str []rune, offset int, numGroups int) (
// If the first state is an assertion, makes sure the assertion
// is true before we do _anything_ else.
if start.assert != NONE {
if start.assert != noneAssert {
if start.checkAssertion(str, offset) == false {
i++
return false, []Group{}, i
@@ -329,7 +329,7 @@ func findAllMatchesHelper(start *State, str []rune, offset int, numGroups int) (
// b. Empty
// c. Doesn't assert anything
for _, s := range currentStates {
if s.isLast && s.isEmpty && s.assert == NONE {
if s.isLast && s.isEmpty && s.assert == noneAssert {
lastStatePtr = s
lastStateInList = true
}
@@ -391,7 +391,7 @@ func findAllMatchesHelper(start *State, str []rune, offset int, numGroups int) (
// Only add the match if the start index is in bounds. If the state has an assertion,
// make sure the assertion checks out.
if state.isLast && i <= len(str) {
if state.assert == NONE || state.checkAssertion(str, i) {
if state.assert == noneAssert || state.checkAssertion(str, i) {
for j := 1; j < numGroups+1; j++ {
tempIndices[j] = state.threadGroups[j]
}

52
regex/nfa.go
View File

@@ -10,16 +10,16 @@ const EPSILON int = 0xF0000
type assertType int
const (
NONE assertType = iota
SOS
EOS
WBOUND
NONWBOUND
PLA // Positive lookahead
NLA // Negative lookahead
PLB // Positive lookbehind
NLB // Negative lookbehind
ALWAYS_TRUE // An assertion that is always true
noneAssert assertType = iota
sosAssert
eosAssert
wboundAssert
nonwboundAssert
plaAssert // Positive lookahead
nlaAssert // Negative lookahead
plbAssert // Positive lookbehind
nlbAssert // Negative lookbehind
alwaysTrueAssert // An assertion that is always true
)
type State struct {
@@ -105,24 +105,24 @@ func cloneStateHelper(state *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 {
if s.assert == ALWAYS_TRUE {
if s.assert == alwaysTrueAssert {
return true
}
if s.assert == SOS {
if s.assert == sosAssert {
// Single-line mode: Beginning of string
// Multi-line mode: Previous character was newline
return idx == 0 || (multilineMode && (idx > 0 && str[idx-1] == '\n'))
}
if s.assert == EOS {
if s.assert == eosAssert {
// Single-line mode: End of string
// Multi-line mode: current character is newline
// Index is at the end of the string, or it points to the last character which is a newline
return idx == len(str) || (multilineMode && str[idx] == '\n')
}
if s.assert == WBOUND {
if s.assert == wboundAssert {
return isWordBoundary(str, idx)
}
if s.assert == NONWBOUND {
if s.assert == nonwboundAssert {
return !isWordBoundary(str, idx)
}
if s.isLookaround() {
@@ -133,7 +133,7 @@ func (s State) checkAssertion(str []rune, idx int) bool {
startState := s.lookaroundNFA
var runesToMatch []rune
var strToMatch string
if s.assert == PLA || s.assert == NLA {
if s.assert == plaAssert || s.assert == nlaAssert {
runesToMatch = str[idx:]
} else {
runesToMatch = str[:idx]
@@ -149,21 +149,21 @@ func (s State) checkAssertion(str []rune, idx int) bool {
numMatchesFound := 0
for _, matchIdx := range matchIndices {
if s.assert == PLA || s.assert == NLA { // Lookahead - return true (or false) if at least one match starts at 0. Zero is used because the test-string _starts_ from idx.
if s.assert == plaAssert || s.assert == nlaAssert { // Lookahead - return true (or false) if at least one match starts at 0. Zero is used because the test-string _starts_ from idx.
if matchIdx[0].StartIdx == 0 {
numMatchesFound++
}
}
if s.assert == PLB || s.assert == NLB { // Lookbehind - return true (or false) if at least one match _ends_ at the current index.
if s.assert == plbAssert || s.assert == nlbAssert { // Lookbehind - return true (or false) if at least one match _ends_ at the current index.
if matchIdx[0].EndIdx == idx {
numMatchesFound++
}
}
}
if s.assert == PLA || s.assert == PLB { // Positive assertions want at least one match
if s.assert == plaAssert || s.assert == plbAssert { // Positive assertions want at least one match
return numMatchesFound > 0
}
if s.assert == NLA || s.assert == NLB { // Negative assertions only want zero matches
if s.assert == nlaAssert || s.assert == nlbAssert { // Negative assertions only want zero matches
return numMatchesFound == 0
}
}
@@ -172,7 +172,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 {
if s.assert != NONE {
if s.assert != noneAssert {
return s.checkAssertion(str, idx)
}
if s.allChars {
@@ -183,7 +183,7 @@ func (s State) contentContains(str []rune, idx int) bool {
}
func (s State) isLookaround() bool {
return s.assert == PLA || s.assert == PLB || s.assert == NLA || s.assert == NLB
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.
@@ -192,7 +192,7 @@ 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 != NONE {
if s.assert != noneAssert {
if s.checkAssertion(str, idx) == false {
return make([]*State, 0), -1
}
@@ -270,7 +270,7 @@ func concatenate(s1 *State, s2 *State) *State {
}
func kleene(s1 State) (*State, error) {
if s1.isEmpty && s1.assert != NONE {
if s1.isEmpty && s1.assert != noneAssert {
return nil, fmt.Errorf("previous token is not quantifiable")
}
@@ -328,7 +328,7 @@ func newState() State {
ret := State{
output: make([]*State, 0),
transitions: make(map[int][]*State),
assert: NONE,
assert: noneAssert,
except: append([]rune{}, 0),
lookaroundRegex: "",
groupEnd: false,
@@ -343,6 +343,6 @@ func zeroLengthMatchState() State {
start := newState()
start.content = newContents(EPSILON)
start.isEmpty = true
start.assert = ALWAYS_TRUE
start.assert = alwaysTrueAssert
return start
}