Made shuntingYard return an error instead of panicking, moved it and thompson to compile.go
parent
72263509d3
commit
ddbcb309b0
@ -0,0 +1,574 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"slices"
|
||||
"strconv"
|
||||
"unicode"
|
||||
)
|
||||
|
||||
/*
|
||||
The Shunting-Yard algorithm is used to convert the given infix (regeular) expression to postfix.
|
||||
The primary benefit of this is getting rid of parentheses.
|
||||
It also inserts explicit concatenation operators to make parsing easier in Thompson's algorithm.
|
||||
An error can be returned for a multitude of reasons - the reason is specified in the error string.
|
||||
See: https://blog.cernera.me/converting-regular-expressions-to-postfix-notation-with-the-shunting-yard-algorithm/
|
||||
*/
|
||||
func shuntingYard(re string) ([]postfixNode, error) {
|
||||
re_postfix := make([]rune, 0)
|
||||
// Convert the string to a slice of runes to allow iteration through it
|
||||
re_runes_orig := []rune(re) // This is the rune slice before the first parsing loop (which detects and replaces numeric ranges)
|
||||
re_runes := make([]rune, 0)
|
||||
// Check for numeric range. If we are at the start of a numeric range,
|
||||
// skip to end and construct the equivalent regex for the range.
|
||||
// The reason this is outside the loop below, is that it actually modifies
|
||||
// the given regex (we 'cut' the numeric range and 'paste' an equivalent regex).
|
||||
// It also makes the overall parsing easier, since I don't have to worry about the numeric range
|
||||
// anymore.
|
||||
// Eventually, I might be able to add it into the main parsing loop, to reduce the time
|
||||
// complexity.
|
||||
// A numeric range has the syntax: <num1-num2>. Ir matches all numbers in this range.
|
||||
//
|
||||
// Also check for non-capturing groups. The LPAREN of a non-capturing group looks like this: '(?:'
|
||||
// I take this out, and put in a special character - NONCAPLPAREN_CHAR.
|
||||
for i := 0; i < len(re_runes_orig); i++ {
|
||||
c := re_runes_orig[i]
|
||||
if c == '<' && (i == 0 || (re_runes_orig[i-1] != '\\' && re_runes_orig[i-1] != '?')) {
|
||||
i++ // Step over opening angle bracket
|
||||
tmpStr := ""
|
||||
hyphenFound := false
|
||||
for i < len(re_runes_orig) && re_runes_orig[i] != '>' {
|
||||
if !unicode.IsDigit(re_runes_orig[i]) {
|
||||
if re_runes_orig[i] != '-' || (hyphenFound) {
|
||||
return nil, fmt.Errorf("Invalid numeric range.")
|
||||
}
|
||||
}
|
||||
if re_runes_orig[i] == '-' {
|
||||
hyphenFound = true
|
||||
}
|
||||
tmpStr += string(re_runes_orig[i])
|
||||
i++
|
||||
}
|
||||
// End of string reached and last character doesn't close the range
|
||||
if i == len(re_runes_orig) && re_runes_orig[len(re_runes_orig)-1] != '>' {
|
||||
return nil, fmt.Errorf("Numeric range not closed.")
|
||||
}
|
||||
if len(tmpStr) == 0 {
|
||||
return nil, fmt.Errorf("Empty numeric range.")
|
||||
}
|
||||
// Closing bracket will be skipped when the loop variable increments
|
||||
var rangeStart int
|
||||
var rangeEnd int
|
||||
fmt.Sscanf(tmpStr, "%d-%d", &rangeStart, &rangeEnd)
|
||||
regex := range2regex(rangeStart, rangeEnd)
|
||||
re_runes = append(re_runes, []rune(regex)...)
|
||||
} else if c == '(' && i < len(re_runes_orig)-2 && re_runes_orig[i+1] == '?' && re_runes_orig[i+2] == ':' {
|
||||
re_runes = append(re_runes, NONCAPLPAREN_CHAR)
|
||||
i += 2
|
||||
} else {
|
||||
re_runes = append(re_runes, c)
|
||||
}
|
||||
}
|
||||
|
||||
/* Add concatenation operators.
|
||||
Only add a concatenation operator between two characters if both the following conditions are met:
|
||||
1. The first character isn't an opening parantheses or alteration operator (or an escape character)
|
||||
a. This makes sense, because these operators can't be _concatenated_ with anything else.
|
||||
2. The second character isn't a 'closing operator' - one that applies to something before it
|
||||
a. Again, these operators can'be concatenated _to_. They can, however, be concatenated _from_.
|
||||
Caveats:
|
||||
1. Don't mess with anything inside brackets - character class
|
||||
2. Don't mess with anything inside braces - numeric repetition
|
||||
3. Don't mess with any lookarounds.
|
||||
*/
|
||||
i := 0
|
||||
for i < len(re_runes) {
|
||||
re_postfix = append(re_postfix, re_runes[i])
|
||||
if re_runes[i] == '[' && (i == 0 || re_runes[i-1] != '\\') { // We do not touch things inside brackets, unless they are escaped. Inside this block, the only task is to expand character ranges into their constituent characters.
|
||||
re_postfix[len(re_postfix)-1] = LBRACKET // Replace the '[' character with LBRACKET. This allows for easier parsing of all characters (including opening and closing brackets) within the character class
|
||||
toAppend := make([]rune, 0) // Holds all the runes in the current character class
|
||||
if i < len(re_runes)-1 && re_runes[i+1] == '^' { // Inverting class - match everything NOT in brackets
|
||||
re_postfix = append(re_postfix, '^')
|
||||
i++ // Skip opening bracket and caret
|
||||
}
|
||||
if i < len(re_runes)-1 && re_runes[i+1] == ']' { // Nothing inside brackets - panic.
|
||||
return nil, fmt.Errorf("Empty character class.")
|
||||
}
|
||||
for re_runes[i] != ']' {
|
||||
i++ // Skip all characters inside brackets
|
||||
// TODO: Check for escaped characters
|
||||
|
||||
// Check ahead for character range
|
||||
if i < len(re_runes)-2 && re_runes[i+1] == '-' {
|
||||
rangeStart := re_runes[i]
|
||||
rangeEnd := re_runes[i+2]
|
||||
if int(rangeEnd) < int(rangeStart) {
|
||||
return nil, fmt.Errorf("Range is out of order.")
|
||||
}
|
||||
|
||||
for i := rangeStart; i <= rangeEnd; i++ {
|
||||
toAppend = append(toAppend, i)
|
||||
}
|
||||
|
||||
i += 2 // Skip start and hyphen (end will automatically be skipped on next iteration of loop)
|
||||
continue
|
||||
}
|
||||
toAppend = append(toAppend, re_runes[i])
|
||||
}
|
||||
// Replace the last character (which should have been ']', with RBRACKET
|
||||
toAppend[len(toAppend)-1] = RBRACKET
|
||||
re_postfix = append(re_postfix, toAppend...)
|
||||
}
|
||||
if i < len(re_runes) && re_runes[i] == '{' && (i > 0 && re_runes[i-1] != '\\') { // We don't touch things inside braces, either
|
||||
i++ // Skip opening brace
|
||||
for i < len(re_runes) && re_runes[i] != '}' {
|
||||
re_postfix = append(re_postfix, re_runes[i])
|
||||
i++
|
||||
}
|
||||
if i == len(re_runes) {
|
||||
return nil, fmt.Errorf("Invalid numeric specifier.")
|
||||
}
|
||||
re_postfix = append(re_postfix, re_runes[i]) // Append closing brace
|
||||
}
|
||||
if i < len(re_runes)-3 && string(re_runes[i+1:i+4]) == "(?:" { // Non-capturing lparen
|
||||
re_postfix = append(re_postfix, NONCAPLPAREN_CHAR)
|
||||
i += 3
|
||||
}
|
||||
if i < len(re_runes) && re_runes[i] == '(' && (i == 0 || re_runes[i-1] != '\\') && (i < len(re_runes)-2 && re_runes[i+1] == '?' && slices.Contains([]rune{'=', '!', '<'}, re_runes[i+2])) { // Unescaped open parentheses followed by question mark then '<', '!' or '=' => lokaround. Don't mess with it.
|
||||
i++ // Step inside
|
||||
if i == len(re_runes)-1 || (re_runes[i+1] != '=' && re_runes[i+1] != '!' && re_runes[i+1] != '<') {
|
||||
return nil, fmt.Errorf("Invalid regex. Lookaround intended?")
|
||||
}
|
||||
re_postfix = append(re_postfix, re_runes[i])
|
||||
i++
|
||||
numOpenParens := 1
|
||||
for numOpenParens != 0 {
|
||||
if i >= len(re_runes) {
|
||||
return nil, fmt.Errorf("Unclosed lookaround.")
|
||||
}
|
||||
if re_runes[i] == '(' {
|
||||
numOpenParens++
|
||||
}
|
||||
if re_runes[i] == ')' {
|
||||
numOpenParens--
|
||||
if numOpenParens == 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
re_postfix = append(re_postfix, re_runes[i])
|
||||
i++
|
||||
}
|
||||
continue
|
||||
}
|
||||
if i < len(re_runes) && (re_runes[i] != '(' && re_runes[i] != NONCAPLPAREN_CHAR && re_runes[i] != '|' && re_runes[i] != '\\') || (i > 0 && re_runes[i-1] == '\\') { // Every character should be concatenated if it is escaped
|
||||
if i < len(re_runes)-1 {
|
||||
if re_runes[i+1] != '|' && re_runes[i+1] != '*' && re_runes[i+1] != '+' && re_runes[i+1] != '?' && re_runes[i+1] != ')' && re_runes[i+1] != '{' {
|
||||
re_postfix = append(re_postfix, CONCAT)
|
||||
}
|
||||
}
|
||||
}
|
||||
i++
|
||||
}
|
||||
|
||||
opStack := make([]rune, 0) // Operator stack
|
||||
outQueue := make([]postfixNode, 0) // Output queue
|
||||
|
||||
// Actual algorithm
|
||||
numOpenParens := 0 // Number of open parentheses
|
||||
for i := 0; i < len(re_postfix); i++ {
|
||||
/* Two cases:
|
||||
1. Current character is alphanumeric - send to output queue
|
||||
2. Current character is operator - do the following:
|
||||
a. If current character has greater priority than top of opStack, push to opStack.
|
||||
b. If not, keep popping from opStack (and appending to outQueue) until:
|
||||
i. opStack is empty, OR
|
||||
ii. current character has greater priority than top of opStack
|
||||
3. If current character is '(' or NONCAPLPAREN_CHAR, push to opStack
|
||||
4. If current character is ')', pop from opStack (and append to outQueue) until '(' is found. Discard parantheses.
|
||||
5. If current character is '[', find all the characters until ']', then create a postfixNode containing all these contents. Add this node to outQueue.
|
||||
6. If current character is '{', find the appropriate numeric specifier (range start, range end). Apply the range to the postfixNode at the end of outQueue.
|
||||
*/
|
||||
c := re_postfix[i]
|
||||
if isNormalChar(c) {
|
||||
if caseInsensitiveFlag != nil && *caseInsensitiveFlag {
|
||||
outQueue = append(outQueue, newPostfixNode(allCases(c)...))
|
||||
} else {
|
||||
outQueue = append(outQueue, newPostfixNode(c))
|
||||
}
|
||||
continue
|
||||
}
|
||||
// Escape character
|
||||
if c == '\\' { // Escape character - invert special and non-special characters eg. \( is treated as a literal parentheses, \b is treated as word boundary
|
||||
if i == len(re_postfix)-1 { // End of string - panic, because backslash is an escape character (something needs to come after it)
|
||||
return nil, fmt.Errorf("ERROR: Backslash with no escape character.")
|
||||
}
|
||||
i++
|
||||
outQueue = append(outQueue, newEscapedNode(re_postfix[i]))
|
||||
continue // Escaped character will automatically be skipped when loop variable increments
|
||||
}
|
||||
|
||||
if c == '.' { // Dot metacharacter - represents 'any' character, but I am only adding Unicode 0020-007E
|
||||
outQueue = append(outQueue, newPostfixDotNode())
|
||||
continue
|
||||
}
|
||||
if c == '^' { // Start-of-string assertion
|
||||
outQueue = append(outQueue, newPostfixNode(c))
|
||||
}
|
||||
if c == '$' { // End-of-string assertion
|
||||
outQueue = append(outQueue, newPostfixNode(c))
|
||||
}
|
||||
// Check if we're at the start of a lookaround
|
||||
if c == '(' && i < len(re_postfix)-1 && re_postfix[i+1] == '?' {
|
||||
i += 2 // Skip opening paren and question mark
|
||||
regex := "" // Stores lookaround regex
|
||||
numOpenParens := 1
|
||||
for numOpenParens != 0 {
|
||||
if i >= len(re_postfix) {
|
||||
return nil, fmt.Errorf("Unclosed lookaround.")
|
||||
}
|
||||
if re_postfix[i] == '(' {
|
||||
numOpenParens++
|
||||
}
|
||||
if re_postfix[i] == ')' {
|
||||
numOpenParens--
|
||||
if numOpenParens == 0 {
|
||||
break
|
||||
}
|
||||
}
|
||||
regex += string(re_postfix[i])
|
||||
i++
|
||||
}
|
||||
if len(regex) <= 1 { // Nothing in regex - panic
|
||||
return nil, fmt.Errorf("Invalid lookaround. (too short?)")
|
||||
}
|
||||
// 'regex' should now contain the lookaround regex, plus the characters at the start (which indicate pos/neg, ahead/behind)
|
||||
// Now we should filter that out.
|
||||
toAppend := postfixNode{nodetype: ASSERTION, startReps: 1, endReps: 1}
|
||||
if regex[0] == '<' { // Lookbehind
|
||||
toAppend.lookaroundDir = LOOKBEHIND
|
||||
regex = regex[1:]
|
||||
} else if regex[0] == '=' || regex[0] == '!' {
|
||||
toAppend.lookaroundDir = LOOKAHEAD
|
||||
} else {
|
||||
return nil, fmt.Errorf("Invalid lookaround.")
|
||||
}
|
||||
// Positive or negative
|
||||
if regex[0] == '=' { // Positive
|
||||
toAppend.lookaroundSign = POSITIVE
|
||||
toAppend.contents = []rune(regex[1:])
|
||||
} else if regex[0] == '!' { // Negative
|
||||
toAppend.lookaroundSign = NEGATIVE
|
||||
toAppend.contents = []rune(regex[1:])
|
||||
} else {
|
||||
return nil, fmt.Errorf("Invalid lookaround.")
|
||||
}
|
||||
outQueue = append(outQueue, toAppend)
|
||||
continue
|
||||
}
|
||||
if isOperator(c) {
|
||||
if len(opStack) == 0 {
|
||||
opStack = append(opStack, c)
|
||||
} else {
|
||||
topStack, err := peek(opStack)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Operator without operand.")
|
||||
}
|
||||
if priority(c) > priority(topStack) { // 2a
|
||||
opStack = append(opStack, c)
|
||||
} else {
|
||||
for priority(c) <= priority(topStack) { // 2b
|
||||
to_append := mustPop(&opStack)
|
||||
outQueue = append(outQueue, newPostfixNode(to_append))
|
||||
topStack, _ = peek(opStack)
|
||||
}
|
||||
opStack = append(opStack, c)
|
||||
}
|
||||
}
|
||||
}
|
||||
if c == LBRACKET { // Used for character classes
|
||||
i++ // Step forward so we can look at the character class
|
||||
var invertMatch bool
|
||||
if re_postfix[i] == '^' {
|
||||
invertMatch = true
|
||||
i++
|
||||
}
|
||||
chars := make([]rune, 0) // List of characters - used only for character classes
|
||||
for i < len(re_postfix) {
|
||||
if re_postfix[i] == RBRACKET {
|
||||
break
|
||||
}
|
||||
chars = append(chars, re_postfix[i])
|
||||
i++
|
||||
}
|
||||
if i == len(re_postfix) { // We have reached the end of the string, so we didn't encounter a closing brakcet. Panic.
|
||||
return nil, fmt.Errorf("Opening bracket without closing bracket.")
|
||||
}
|
||||
if !invertMatch {
|
||||
outQueue = append(outQueue, newPostfixCharNode(chars...))
|
||||
} else {
|
||||
// Invert match - create an allChars postfixNode, then add the given states to its 'except' list.
|
||||
toAdd := newPostfixDotNode()
|
||||
toAdd.except = chars
|
||||
outQueue = append(outQueue, toAdd)
|
||||
}
|
||||
continue
|
||||
}
|
||||
if c == '{' {
|
||||
i++ // Skip opening brace
|
||||
// Three possibilities:
|
||||
// 1. Single number - {5}
|
||||
// 2. Range - {3,5}
|
||||
// 3. Start with no end, {3,}
|
||||
startRange := make([]rune, 0)
|
||||
startRangeNum := 0
|
||||
endRange := make([]rune, 0)
|
||||
endRangeNum := 0
|
||||
for i < len(re_postfix) && unicode.IsDigit(re_postfix[i]) {
|
||||
startRange = append(startRange, re_postfix[i])
|
||||
i++
|
||||
}
|
||||
if len(startRange) == 0 { // {} is not valid, neither is {,5}
|
||||
return nil, fmt.Errorf("Invalid numeric specifier.")
|
||||
}
|
||||
if i == len(re_postfix) {
|
||||
return nil, fmt.Errorf("Brace not closed.")
|
||||
}
|
||||
|
||||
startRangeNum, err := strconv.Atoi(string(startRange))
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
if re_postfix[i] == '}' { // Case 1 above
|
||||
endRangeNum = startRangeNum
|
||||
} else {
|
||||
if re_postfix[i] != ',' {
|
||||
return nil, fmt.Errorf("Invalid numeric specifier.")
|
||||
}
|
||||
i++ // Skip comma
|
||||
for i < len(re_postfix) && unicode.IsDigit(re_postfix[i]) {
|
||||
endRange = append(endRange, re_postfix[i])
|
||||
i++
|
||||
}
|
||||
if i == len(re_postfix) {
|
||||
return nil, fmt.Errorf("Brace not closed.")
|
||||
}
|
||||
if re_postfix[i] != '}' {
|
||||
return nil, fmt.Errorf("Invalid numeric specifier.")
|
||||
}
|
||||
if len(endRange) == 0 { // Case 3 above
|
||||
endRangeNum = INFINITE_REPS
|
||||
} else { // Case 2 above
|
||||
var err error
|
||||
endRangeNum, err = strconv.Atoi(string(endRange))
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
idx := len(outQueue) - 1
|
||||
// Get the last added node
|
||||
if idx < 0 || outQueue[idx].nodetype == LPAREN {
|
||||
return nil, fmt.Errorf("Numeric specifier with no content.")
|
||||
}
|
||||
outQueue[idx].startReps = startRangeNum
|
||||
outQueue[idx].endReps = endRangeNum
|
||||
}
|
||||
if c == '(' || c == NONCAPLPAREN_CHAR {
|
||||
opStack = append(opStack, c)
|
||||
if c == '(' { // We only push _capturing_ group parentheses to outQueue
|
||||
outQueue = append(outQueue, newPostfixNode(c))
|
||||
}
|
||||
numOpenParens++
|
||||
}
|
||||
if c == ')' {
|
||||
// Keep popping from opStack until we encounter an opening parantheses or a NONCAPLPAREN_CHAR. Panic if we reach the end of the stack.
|
||||
var val rune
|
||||
var err error
|
||||
for val, err = peek(opStack); val != '(' && val != NONCAPLPAREN_CHAR; val, err = peek(opStack) {
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Imbalanced parantheses.")
|
||||
}
|
||||
to_append := mustPop(&opStack)
|
||||
outQueue = append(outQueue, newPostfixNode(to_append))
|
||||
}
|
||||
_ = mustPop(&opStack) // Get rid of opening parentheses
|
||||
if val == '(' { // Whatever was inside the parentheses was a _capturing_ group, so we append the closing parentheses as well
|
||||
outQueue = append(outQueue, newPostfixNode(')')) // Add closing parentheses
|
||||
}
|
||||
numOpenParens--
|
||||
}
|
||||
}
|
||||
|
||||
// Pop all remaining operators (and append to outQueue)
|
||||
for len(opStack) > 0 {
|
||||
to_append := mustPop(&opStack)
|
||||
outQueue = append(outQueue, newPostfixNode(to_append))
|
||||
}
|
||||
|
||||
if numOpenParens != 0 {
|
||||
return nil, fmt.Errorf("Imbalanced parantheses.")
|
||||
}
|
||||
|
||||
return outQueue, nil
|
||||
}
|
||||
|
||||
// Thompson's algorithm. Constructs Finite-State Automaton from given string.
|
||||
// Returns start state and number of groups in regex.
|
||||
func thompson(re []postfixNode) (*State, int) {
|
||||
nfa := make([]*State, 0) // Stack of states
|
||||
numGroups := 0 // Number of capturing groups
|
||||
for _, c := range re {
|
||||
if c.nodetype == CHARACTER || c.nodetype == ASSERTION {
|
||||
state := State{}
|
||||
state.transitions = make(map[int][]*State)
|
||||
if c.allChars {
|
||||
state.allChars = true
|
||||
if len(c.except) != 0 {
|
||||
state.except = append([]rune{}, c.except...)
|
||||
}
|
||||
}
|
||||
state.content = rune2Contents(c.contents)
|
||||
state.output = make([]*State, 0)
|
||||
state.output = append(state.output, &state)
|
||||
state.isEmpty = false
|
||||
if c.nodetype == ASSERTION {
|
||||
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
|
||||
if c.lookaroundDir == 0 || c.lookaroundSign == 0 {
|
||||
switch c.contents[0] {
|
||||
case '^':
|
||||
state.assert = SOS
|
||||
case '$':
|
||||
state.assert = EOS
|
||||
case 'b':
|
||||
state.assert = WBOUND
|
||||
case 'B':
|
||||
state.assert = NONWBOUND
|
||||
}
|
||||
} else { // Lookaround
|
||||
state.lookaroundRegex = string(c.contents)
|
||||
if c.lookaroundDir == LOOKAHEAD {
|
||||
if c.lookaroundSign == POSITIVE {
|
||||
state.assert = PLA
|
||||
}
|
||||
if c.lookaroundSign == NEGATIVE {
|
||||
state.assert = NLA
|
||||
}
|
||||
}
|
||||
if c.lookaroundDir == LOOKBEHIND {
|
||||
if c.lookaroundSign == POSITIVE {
|
||||
state.assert = PLB
|
||||
}
|
||||
if c.lookaroundSign == NEGATIVE {
|
||||
state.assert = NLB
|
||||
}
|
||||
}
|
||||
tmpRe := shuntingYard(state.lookaroundRegex)
|
||||
var numGroupsLookaround int
|
||||
state.lookaroundNFA, numGroupsLookaround = thompson(tmpRe)
|
||||
state.lookaroundNumCaptureGroups = numGroupsLookaround
|
||||
|
||||
}
|
||||
}
|
||||
nfa = append(nfa, &state)
|
||||
}
|
||||
if c.nodetype == LPAREN || c.nodetype == RPAREN {
|
||||
s := &State{}
|
||||
s.assert = NONE
|
||||
s.content = newContents(EPSILON)
|
||||
s.isEmpty = true
|
||||
s.output = make([]*State, 0)
|
||||
s.output = append(s.output, s)
|
||||
s.transitions = make(map[int][]*State)
|
||||
// LPAREN nodes are just added normally
|
||||
if c.nodetype == LPAREN {
|
||||
numGroups++
|
||||
s.groupBegin = true
|
||||
s.groupNum = numGroups
|
||||
nfa = append(nfa, s)
|
||||
continue
|
||||
}
|
||||
// For RPAREN nodes, I assume that the last two nodes in the list are an LPAREN,
|
||||
// and then some other node.
|
||||
// These three nodes (LPAREN, the middle node and RPAREN) are extracted together, concatenated
|
||||
// and added back in.
|
||||
if c.nodetype == RPAREN {
|
||||
s.groupEnd = true
|
||||
middleNode := mustPop(&nfa)
|
||||
lparenNode := mustPop(&nfa)
|
||||
s.groupNum = lparenNode.groupNum
|
||||
tmp := concatenate(lparenNode, middleNode)
|
||||
to_add := concatenate(tmp, s)
|
||||
nfa = append(nfa, to_add)
|
||||
|
||||
}
|
||||
}
|
||||
// Must be an operator if it isn't a character
|
||||
switch c.nodetype {
|
||||
case CONCATENATE:
|
||||
s2 := mustPop(&nfa)
|
||||
s1 := mustPop(&nfa)
|
||||
s1 = concatenate(s1, s2)
|
||||
nfa = append(nfa, s1)
|
||||
case KLEENE: // Create a 0-state, concat the popped state after it, concat the 0-state after the popped state
|
||||
s1 := mustPop(&nfa)
|
||||
stateToAdd := kleene(*s1)
|
||||
nfa = append(nfa, stateToAdd)
|
||||
case PLUS: // a+ is equivalent to aa*
|
||||
s1 := mustPop(&nfa)
|
||||
s2 := kleene(*s1)
|
||||
s1 = concatenate(s1, s2)
|
||||
nfa = append(nfa, s1)
|
||||
case QUESTION: // ab? is equivalent to a(b|)
|
||||
s1 := mustPop(&nfa)
|
||||
s2 := question(s1)
|
||||
nfa = append(nfa, s2)
|
||||
case PIPE:
|
||||
s1 := mustPop(&nfa)
|
||||
s2 := mustPop(&nfa)
|
||||
s3 := alternate(s1, s2)
|
||||
nfa = append(nfa, s3)
|
||||
}
|
||||
if c.startReps != 1 || c.endReps != 1 { // Must have a numeric specifier attached to it
|
||||
if c.endReps != -1 && c.endReps < c.startReps {
|
||||
panic("ERROR: Numeric specifier - start greater than end.")
|
||||
}
|
||||
state := mustPop(&nfa)
|
||||
var stateToAdd *State = nil
|
||||
// Take advantage of the following facts:
|
||||
// a{5} == aaaaa
|
||||
// a{3,5} == aaaa?a?
|
||||
// a{5,} == aaaaa+
|
||||
// Nov. 3 2024 - I have two choices on how I want to implement numeric
|
||||
// specifiers.
|
||||
// a. Encode the logic while creating the states. I will have to create a function
|
||||
// that creates a deep-copy of a given state / NFA, so that I can concatenate them to
|
||||
// each other (concatenating them with the 'concatenate' method - which takes addresses - does
|
||||
// not work). Creating this function might be a lot of work.
|
||||
// b. Encode the logic while parsing the string (shunting-yard). If I can expand the numeric specifier
|
||||
// at this point, I can leave thompson untouched.
|
||||
for i := 0; i < c.startReps; i++ { // Case 1
|
||||
stateToAdd = concatenate(stateToAdd, cloneState(state))
|
||||
}
|
||||
if c.endReps == INFINITE_REPS { // Case 3
|
||||
s2 := kleene(*state)
|
||||
stateToAdd = concatenate(stateToAdd, s2)
|
||||
} else { // Case 2
|
||||
for i := c.startReps; i < c.endReps; i++ {
|
||||
stateToAdd = concatenate(stateToAdd, question(state))
|
||||
}
|
||||
}
|
||||
nfa = append(nfa, stateToAdd)
|
||||
}
|
||||
}
|
||||
if len(nfa) != 1 {
|
||||
panic("ERROR: Invalid Regex.")
|
||||
}
|
||||
|
||||
verifyLastStates(nfa)
|
||||
|
||||
return nfa[0], numGroups
|
||||
|
||||
}
|
Loading…
Reference in New Issue