From 7e88b8a4b08423b8b92f1c6ea16557384d2f6b99 Mon Sep 17 00:00:00 2001 From: Aadhavan Srinivasan Date: Thu, 30 Jan 2025 10:24:24 -0500 Subject: [PATCH] Renamed variable to avoid conflicting with type name --- regex/compile.go | 54 ++++++++++++++++++++++++------------------------ 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/regex/compile.go b/regex/compile.go index 6f26bed..80a5fce 100644 --- a/regex/compile.go +++ b/regex/compile.go @@ -815,10 +815,10 @@ func thompson(re []postfixNode) (Reg, error) { for _, c := range re { if c.nodetype == characterNode || c.nodetype == assertionNode { - state := State{} - state.transitions = make(map[int][]*State) + stateToAdd := State{} + stateToAdd.transitions = make(map[int][]*State) if c.allChars { - state.allChars = true + stateToAdd.allChars = true if len(c.except) != 0 { // For each node that I am 'excepting' (eg. in an inverted character class): // - If the node itself has exceptions, then the exceptions cancel out. @@ -827,7 +827,7 @@ func thompson(re []postfixNode) (Reg, error) { // - If the node doesn't have exceptions (allChars == false) then the contents of the node are added to the except list. for _, node := range c.except { if node.allChars { - state.allChars = false + stateToAdd.allChars = false // For each postfixNode in node.except, extract the contents of the postfixNode. Concatenate them all, // and them to the state's _content_. As mentioned above, if the exception has exceptions, then we can match // those. @@ -840,7 +840,7 @@ func thompson(re []postfixNode) (Reg, error) { } return nodeContents })...) - state.content = rune2Contents(nodeExceptChars) + stateToAdd.content = rune2Contents(nodeExceptChars) } else { charsToAdd := node.contents if caseInsensitive { @@ -848,7 +848,7 @@ func thompson(re []postfixNode) (Reg, error) { return allCases(r, caseInsensitive) })...) } - state.except = append(state.except, charsToAdd...) + stateToAdd.except = append(stateToAdd.except, charsToAdd...) } } } @@ -861,43 +861,43 @@ func thompson(re []postfixNode) (Reg, error) { return allCases(r, caseInsensitive) })...) } - state.content = stateContents(append([]int(state.content), []int(rune2Contents(runesToAdd))...)) - state.output = make([]*State, 0) - state.output = append(state.output, &state) - state.isEmpty = false + stateToAdd.content = stateContents(append([]int(stateToAdd.content), []int(rune2Contents(runesToAdd))...)) + stateToAdd.output = make([]*State, 0) + stateToAdd.output = append(stateToAdd.output, &stateToAdd) + stateToAdd.isEmpty = false if c.nodetype == assertionNode { - state.isEmpty = true // This is a little weird. A lookaround has the 'isEmpty' flag set, even though it _isn't_ empty (the contents are the regex). But, there's so much error-checking that relies on this flag that it's better to keep it this way. - state.content = newContents(EPSILON) // Ideally, an assertion shouldn't have any content, since it doesn't say anything about the content of string + stateToAdd.isEmpty = true // This is a little weird. A lookaround has the 'isEmpty' flag set, even though it _isn't_ empty (the contents are the regex). But, there's so much error-checking that relies on this flag that it's better to keep it this way. + stateToAdd.content = newContents(EPSILON) // Ideally, an assertion shouldn't have any content, since it doesn't say anything about the content of string if c.lookaroundDir == 0 || c.lookaroundSign == 0 { switch c.contents[0] { case '^': - state.assert = sosAssert + stateToAdd.assert = sosAssert case '$': - state.assert = eosAssert + stateToAdd.assert = eosAssert case 'b': - state.assert = wboundAssert + stateToAdd.assert = wboundAssert case 'B': - state.assert = nonwboundAssert + stateToAdd.assert = nonwboundAssert } } else { // Lookaround - state.lookaroundRegex = string(c.contents) + stateToAdd.lookaroundRegex = string(c.contents) if c.lookaroundDir == lookahead { if c.lookaroundSign == positive { - state.assert = plaAssert + stateToAdd.assert = plaAssert } if c.lookaroundSign == negative { - state.assert = nlaAssert + stateToAdd.assert = nlaAssert } } if c.lookaroundDir == lookbehind { if c.lookaroundSign == positive { - state.assert = plbAssert + stateToAdd.assert = plbAssert } if c.lookaroundSign == negative { - state.assert = nlbAssert + stateToAdd.assert = nlbAssert } } - tmpRe, err := shuntingYard(state.lookaroundRegex) + tmpRe, err := shuntingYard(stateToAdd.lookaroundRegex) if err != nil { return Reg{}, fmt.Errorf("error parsing lookaround: %w", err) } @@ -905,17 +905,17 @@ func thompson(re []postfixNode) (Reg, error) { if err != nil { return Reg{}, fmt.Errorf("error compiling lookaround: %w", err) } - state.lookaroundNFA = reg.start - state.lookaroundNumCaptureGroups = reg.numGroups + stateToAdd.lookaroundNFA = reg.start + stateToAdd.lookaroundNumCaptureGroups = reg.numGroups } } // Replace ESC_BACKSLASH with actual backslash, so that we can actually check if we encounter it - replaceByValue([]int(state.content), int(ESC_BACKSLASH), '\\') - replaceByValue(state.except, ESC_BACKSLASH, '\\') + replaceByValue([]int(stateToAdd.content), int(ESC_BACKSLASH), '\\') + replaceByValue(stateToAdd.except, ESC_BACKSLASH, '\\') - nfa = append(nfa, &state) + nfa = append(nfa, &stateToAdd) } if c.nodetype == lparenNode || c.nodetype == rparenNode { s := &State{}