Changed error messages - removed capitalization and punctuation to find Go's error message guidelines
This commit is contained in:
110
compile.go
110
compile.go
@@ -127,7 +127,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
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.")
|
||||
return nil, fmt.Errorf("invalid numeric range")
|
||||
}
|
||||
}
|
||||
if re_runes_orig[i] == '-' {
|
||||
@@ -138,10 +138,10 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
}
|
||||
// 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.")
|
||||
return nil, fmt.Errorf("numeric range not closed")
|
||||
}
|
||||
if len(tmpStr) == 0 {
|
||||
return nil, fmt.Errorf("Empty numeric range.")
|
||||
return nil, fmt.Errorf("empty numeric range")
|
||||
}
|
||||
// Closing bracket will be skipped when the loop variable increments
|
||||
var rangeStart int
|
||||
@@ -185,13 +185,13 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
|
||||
i++ // Skip past LBRACKET, because it was already added
|
||||
if i >= len(re_runes) { // Sanity check before we start
|
||||
return nil, fmt.Errorf("Opening bracket without closing bracket.")
|
||||
return nil, fmt.Errorf("opening bracket without closing bracket")
|
||||
}
|
||||
|
||||
for re_runes[i] != RBRACKET || i == 0 || re_runes[i-1] == '\\' { // Skip all characters inside _unescaped_ brackets (we are _not_ at a closing bracket, or if we are, the previous character is a backslash)
|
||||
// Make sure we haven't exceeded the length of the string. If we did, then the regex doesn't actually have a closing bracket and we should throw an error.
|
||||
if i >= len(re_runes) {
|
||||
return nil, fmt.Errorf("Opening bracket without closing bracket.")
|
||||
return nil, fmt.Errorf("opening bracket without closing bracket")
|
||||
}
|
||||
|
||||
if re_runes[i] == LBRACKET && re_runes[i+1] == ':' { // POSIX character class
|
||||
@@ -204,7 +204,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
i++
|
||||
}
|
||||
if i >= len(re_runes)-1 && re_runes[i] != ':' {
|
||||
return nil, fmt.Errorf("Unable to parse what looks like a POSIX character class.")
|
||||
return nil, fmt.Errorf("unable to parse what looks like a POSIX character class")
|
||||
}
|
||||
toAppend = append(toAppend, re_runes[i])
|
||||
i++
|
||||
@@ -226,7 +226,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
i++
|
||||
}
|
||||
if i == len(re_runes) {
|
||||
return nil, fmt.Errorf("Invalid numeric specifier.")
|
||||
return nil, fmt.Errorf("invalid numeric specifier")
|
||||
}
|
||||
re_postfix = append(re_postfix, re_runes[i]) // Append closing brace
|
||||
}
|
||||
@@ -237,25 +237,25 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
if i < len(re_runes) && re_runes[i] == '\\' { // Something is being escaped (I don't add the backslash to re_postfix, because it was already added earlier)
|
||||
i++
|
||||
if i >= len(re_runes) {
|
||||
return nil, fmt.Errorf("Stray backslash in expression.")
|
||||
return nil, fmt.Errorf("stray backslash in expression")
|
||||
}
|
||||
if re_runes[i] == 'x' {
|
||||
re_postfix = append(re_postfix, re_runes[i])
|
||||
i++
|
||||
if i >= len(re_runes) {
|
||||
return nil, fmt.Errorf("Stray backslash in expression.")
|
||||
return nil, fmt.Errorf("stray backslash in expression")
|
||||
}
|
||||
if re_runes[i] == '{' {
|
||||
re_postfix = append(re_postfix, re_runes[i:i+8]...)
|
||||
i += 7
|
||||
if i >= len(re_runes) {
|
||||
return nil, fmt.Errorf("Stray backslash in expression.")
|
||||
return nil, fmt.Errorf("stray backslash in expression")
|
||||
}
|
||||
} else if isHex(re_runes[i]) {
|
||||
re_postfix = append(re_postfix, re_runes[i:i+2]...)
|
||||
i += 2
|
||||
} else {
|
||||
return nil, fmt.Errorf("Invalid hex value in expression.")
|
||||
return nil, fmt.Errorf("invalid hex value in expression")
|
||||
}
|
||||
} else if isOctal(re_runes[i]) {
|
||||
numDigits := 1
|
||||
@@ -271,14 +271,14 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
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?")
|
||||
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.")
|
||||
return nil, fmt.Errorf("unclosed lookaround")
|
||||
}
|
||||
if re_runes[i] == '(' || re_runes[i] == NONCAPLPAREN_CHAR {
|
||||
numOpenParens++
|
||||
@@ -345,7 +345,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
|
||||
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.")
|
||||
return nil, fmt.Errorf("backslash with no escape character")
|
||||
}
|
||||
i++
|
||||
if re_postfix[i] == 'x' { // Hex value
|
||||
@@ -354,19 +354,19 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
var hexVal int
|
||||
n, err := fmt.Sscanf(string(re_postfix[i:]), "{%x}", &hexVal)
|
||||
if n < 1 || err != nil {
|
||||
return nil, fmt.Errorf("Error parsing expanded hex code in expression.")
|
||||
return nil, fmt.Errorf("error parsing expanded hex code in expression")
|
||||
}
|
||||
outQueue = append(outQueue, newPostfixCharNode(rune(hexVal)))
|
||||
i += 7
|
||||
} else if i < len(re_postfix)-1 { // Two-digit hex code
|
||||
hexVal, err := strconv.ParseInt(string([]rune{re_postfix[i], re_postfix[i+1]}), 16, 64) // Convert the two hex values into a rune slice, then to a string. Parse the string into an int with strconv.ParseInt()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Error parsing hex characters in expression.")
|
||||
return nil, fmt.Errorf("error parsing hex characters in expression")
|
||||
}
|
||||
i++ // Loop increment will take care of going forward
|
||||
outQueue = append(outQueue, newPostfixCharNode(rune(hexVal)))
|
||||
} else {
|
||||
return nil, fmt.Errorf("Not enough hex characters found in expression.")
|
||||
return nil, fmt.Errorf("not enough hex characters found in expression")
|
||||
}
|
||||
} else if isOctal(re_postfix[i]) { // Octal value
|
||||
var octVal int64
|
||||
@@ -378,17 +378,17 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
}
|
||||
octVal, err := strconv.ParseInt(octValStr, 8, 32)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Error parsing octal value in expression.")
|
||||
return nil, fmt.Errorf("error parsing octal value in expression")
|
||||
}
|
||||
if octVal > 0777 {
|
||||
return nil, fmt.Errorf("Invalid octal value in expression.")
|
||||
return nil, fmt.Errorf("invalid octal value in expression")
|
||||
}
|
||||
i += numDigitsParsed - 1 // Shift forward by the number of digits that were parsed. Move back one character, because the loop increment will move us back to the next character automatically
|
||||
outQueue = append(outQueue, newPostfixCharNode(rune(octVal)))
|
||||
} else {
|
||||
escapedNode, err := newEscapedNode(re_postfix[i], false)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Invalid escape character in expression.")
|
||||
return nil, fmt.Errorf("invalid escape character in expression")
|
||||
}
|
||||
outQueue = append(outQueue, escapedNode)
|
||||
}
|
||||
@@ -412,7 +412,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
numOpenParens := 1
|
||||
for numOpenParens != 0 {
|
||||
if i >= len(re_postfix) {
|
||||
return nil, fmt.Errorf("Unclosed lookaround.")
|
||||
return nil, fmt.Errorf("unclosed lookaround")
|
||||
}
|
||||
if re_postfix[i] == '(' || re_postfix[i] == NONCAPLPAREN_CHAR {
|
||||
numOpenParens++
|
||||
@@ -427,7 +427,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
i++
|
||||
}
|
||||
if len(regex) <= 1 { // Nothing in regex - panic
|
||||
return nil, fmt.Errorf("Invalid lookaround. (too short?)")
|
||||
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.
|
||||
@@ -438,7 +438,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
} else if regex[0] == '=' || regex[0] == '!' {
|
||||
toAppend.lookaroundDir = LOOKAHEAD
|
||||
} else {
|
||||
return nil, fmt.Errorf("Invalid lookaround.")
|
||||
return nil, fmt.Errorf("invalid lookaround")
|
||||
}
|
||||
// Positive or negative
|
||||
if regex[0] == '=' { // Positive
|
||||
@@ -448,7 +448,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
toAppend.lookaroundSign = NEGATIVE
|
||||
toAppend.contents = []rune(regex[1:])
|
||||
} else {
|
||||
return nil, fmt.Errorf("Invalid lookaround.")
|
||||
return nil, fmt.Errorf("invalid lookaround")
|
||||
}
|
||||
outQueue = append(outQueue, toAppend)
|
||||
continue
|
||||
@@ -459,7 +459,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
} else {
|
||||
topStack, err := peek(opStack)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Operator without operand.")
|
||||
return nil, fmt.Errorf("operator without operand")
|
||||
}
|
||||
if priority(c) > priority(topStack) { // 2a
|
||||
opStack = append(opStack, c)
|
||||
@@ -479,7 +479,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
i++ // Step forward so we can look at the character class
|
||||
// Oops, there's nothing there to look at
|
||||
if i >= len(re_postfix) {
|
||||
return nil, fmt.Errorf("Opening bracket with no closing bracket.")
|
||||
return nil, fmt.Errorf("opening bracket with no closing bracket")
|
||||
}
|
||||
|
||||
// Check if a POSIX character class was specified ouside a bracket. This is an error.
|
||||
@@ -487,7 +487,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
if re_postfix[i] == ':' {
|
||||
posixClassPresent, _ := getPOSIXClass(re_postfix[i+1:])
|
||||
if posixClassPresent {
|
||||
return nil, fmt.Errorf("The syntax for POSIX character classes is [[:digit:]], not [:digit:]")
|
||||
return nil, fmt.Errorf("the syntax for POSIX character classes is [[:digit:]], not [:digit:]")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -508,7 +508,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
}
|
||||
if re_postfix[i] == '\\' { // Backslash indicates a character to be escaped
|
||||
if i == len(re_postfix)-1 {
|
||||
return nil, fmt.Errorf("Stray backslash in character class.")
|
||||
return nil, fmt.Errorf("stray backslash in character class")
|
||||
}
|
||||
i++ // Step past backslash
|
||||
|
||||
@@ -518,19 +518,19 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
var hexVal int
|
||||
n, err := fmt.Sscanf(string(re_postfix[i:]), "{%x}", &hexVal)
|
||||
if n < 1 || err != nil {
|
||||
return nil, fmt.Errorf("Error parsing expanded hex code in character class.")
|
||||
return nil, fmt.Errorf("error parsing expanded hex code in character class")
|
||||
}
|
||||
chars = append(chars, newPostfixCharNode(rune(hexVal)))
|
||||
i += 8
|
||||
} else if i < len(re_postfix)-2 { // Two-digit hex code
|
||||
hexVal, err := strconv.ParseInt(string([]rune{re_postfix[i], re_postfix[i+1]}), 16, 64) // Convert the two hex values into a rune slice, then to a string. Parse the string into an int with strconv.ParseInt()
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Error parsing hex characters in character class.")
|
||||
return nil, fmt.Errorf("error parsing hex characters in character class")
|
||||
}
|
||||
i += 2
|
||||
chars = append(chars, newPostfixCharNode(rune(hexVal)))
|
||||
} else {
|
||||
return nil, fmt.Errorf("Not enough hex characters found in character class.")
|
||||
return nil, fmt.Errorf("not enough hex characters found in character class")
|
||||
}
|
||||
} else if isOctal(re_postfix[i]) { // Octal value
|
||||
var octVal int64
|
||||
@@ -542,17 +542,17 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
}
|
||||
octVal, err := strconv.ParseInt(octValStr, 8, 32)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Error parsing octal value in character class.")
|
||||
return nil, fmt.Errorf("error parsing octal value in character class")
|
||||
}
|
||||
if octVal > 0777 {
|
||||
return nil, fmt.Errorf("Invalid octal value in character class.")
|
||||
return nil, fmt.Errorf("invalid octal value in character class")
|
||||
}
|
||||
i += numDigitsParsed // Shift forward by the number of characters parsed
|
||||
chars = append(chars, newPostfixCharNode(rune(octVal)))
|
||||
} else {
|
||||
escapedNode, err := newEscapedNode(re_postfix[i], true)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("Invalid escape character in character class.")
|
||||
return nil, fmt.Errorf("invalid escape character in character class")
|
||||
}
|
||||
chars = append(chars, escapedNode)
|
||||
i++
|
||||
@@ -602,7 +602,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
case "word": // Word characters
|
||||
nodeToAdd, _ = newEscapedNode('w', true) // This isn't going to error, so I suppress it
|
||||
default:
|
||||
return nil, fmt.Errorf("Invalid POSIX character class.")
|
||||
return nil, fmt.Errorf("invalid POSIX character class")
|
||||
}
|
||||
chars = append(chars, nodeToAdd)
|
||||
i = temp_i + len(posixClass) + 2 // Skip over the class name, the closing colon and the closing bracket
|
||||
@@ -623,7 +623,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
case RBRACKET:
|
||||
chars = append(chars, newPostfixCharNode(']'))
|
||||
default:
|
||||
return nil, fmt.Errorf("Error parsing high-range unicode value in character class.")
|
||||
return nil, fmt.Errorf("error parsing high-range unicode value in character class")
|
||||
}
|
||||
}
|
||||
chars = append(chars, newPostfixCharNode(re_postfix[i]))
|
||||
@@ -649,7 +649,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
if (err1 != nil || err2 != nil) || len(startRangePostfixNode.contents) != 1 { // Treat it as a regular hyphen
|
||||
chars = append(chars, startRangePostfixNode, newPostfixCharNode('-'), endRangePostfixNode)
|
||||
} else if len(endRangePostfixNode.contents) != 1 { // I don't even know what this would look like, this is just a sanity check
|
||||
return nil, fmt.Errorf("Error parsing character range.")
|
||||
return nil, fmt.Errorf("error parsing character range")
|
||||
} else {
|
||||
// We have established that they both have a length of 1
|
||||
startRangeRune := startRangePostfixNode.contents[0]
|
||||
@@ -661,7 +661,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
}
|
||||
}
|
||||
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.")
|
||||
return nil, fmt.Errorf("opening bracket without closing bracket")
|
||||
}
|
||||
|
||||
outQueue = append(outQueue, newCharClassNode(chars, invertMatch))
|
||||
@@ -682,10 +682,10 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
i++
|
||||
}
|
||||
if len(startRange) == 0 { // {} is not valid, neither is {,5}
|
||||
return nil, fmt.Errorf("Invalid numeric specifier.")
|
||||
return nil, fmt.Errorf("invalid numeric specifier")
|
||||
}
|
||||
if i == len(re_postfix) {
|
||||
return nil, fmt.Errorf("Brace not closed.")
|
||||
return nil, fmt.Errorf("brace not closed")
|
||||
}
|
||||
|
||||
startRangeNum, err := strconv.Atoi(string(startRange))
|
||||
@@ -697,7 +697,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
endRangeNum = startRangeNum
|
||||
} else {
|
||||
if re_postfix[i] != ',' {
|
||||
return nil, fmt.Errorf("Invalid numeric specifier.")
|
||||
return nil, fmt.Errorf("invalid numeric specifier")
|
||||
}
|
||||
i++ // Skip comma
|
||||
for i < len(re_postfix) && unicode.IsDigit(re_postfix[i]) {
|
||||
@@ -705,10 +705,10 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
i++
|
||||
}
|
||||
if i == len(re_postfix) {
|
||||
return nil, fmt.Errorf("Brace not closed.")
|
||||
return nil, fmt.Errorf("brace not closed")
|
||||
}
|
||||
if re_postfix[i] != '}' {
|
||||
return nil, fmt.Errorf("Invalid numeric specifier.")
|
||||
return nil, fmt.Errorf("invalid numeric specifier")
|
||||
}
|
||||
if len(endRange) == 0 { // Case 3 above
|
||||
endRangeNum = INFINITE_REPS
|
||||
@@ -724,7 +724,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
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.")
|
||||
return nil, fmt.Errorf("numeric specifier with no content")
|
||||
}
|
||||
outQueue[idx].startReps = startRangeNum
|
||||
outQueue[idx].endReps = endRangeNum
|
||||
@@ -742,7 +742,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
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.")
|
||||
return nil, fmt.Errorf("imbalanced parantheses")
|
||||
}
|
||||
to_append := mustPop(&opStack)
|
||||
outQueue = append(outQueue, newPostfixNode(to_append))
|
||||
@@ -762,7 +762,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
|
||||
}
|
||||
|
||||
if numOpenParens != 0 {
|
||||
return nil, fmt.Errorf("Imbalanced parantheses.")
|
||||
return nil, fmt.Errorf("imbalanced parantheses")
|
||||
}
|
||||
|
||||
return outQueue, nil
|
||||
@@ -853,11 +853,11 @@ func thompson(re []postfixNode) (Reg, error) {
|
||||
}
|
||||
tmpRe, err := shuntingYard(state.lookaroundRegex)
|
||||
if err != nil {
|
||||
return Reg{}, fmt.Errorf("Error parsing lookaround: %w", err)
|
||||
return Reg{}, fmt.Errorf("error parsing lookaround: %w", err)
|
||||
}
|
||||
reg, err := thompson(tmpRe)
|
||||
if err != nil {
|
||||
return Reg{}, fmt.Errorf("Error compiling lookaround: %w", err)
|
||||
return Reg{}, fmt.Errorf("error compiling lookaround: %w", err)
|
||||
}
|
||||
state.lookaroundNFA = reg.start
|
||||
state.lookaroundNumCaptureGroups = reg.numGroups
|
||||
@@ -899,11 +899,11 @@ func thompson(re []postfixNode) (Reg, error) {
|
||||
middleNode, err1 := pop(&nfa)
|
||||
lparenNode, err2 := pop(&nfa)
|
||||
if err1 != nil && err2 != nil {
|
||||
return Reg{}, fmt.Errorf("Imbalanced parentheses.")
|
||||
return Reg{}, fmt.Errorf("imbalanced parentheses")
|
||||
} else if err2 != nil { // There was no third node. ie. something like '()'
|
||||
lparenNode = middleNode
|
||||
if lparenNode.groupBegin != true { // There are only two nodes, but the first one isn't an LPAREN.
|
||||
return Reg{}, fmt.Errorf("Imbalanced parentheses.")
|
||||
return Reg{}, fmt.Errorf("imbalanced parentheses")
|
||||
}
|
||||
s.groupNum = lparenNode.groupNum
|
||||
to_add := concatenate(lparenNode, s)
|
||||
@@ -915,7 +915,7 @@ func thompson(re []postfixNode) (Reg, error) {
|
||||
} else if middleNode.groupBegin { // Something like 'a()'
|
||||
s.groupNum = middleNode.groupNum
|
||||
} else { // A middleNode and lparenNode exist, but neither is actually an LPAREN.
|
||||
return Reg{}, fmt.Errorf("Imbalanced parentheses.")
|
||||
return Reg{}, fmt.Errorf("imbalanced parentheses")
|
||||
}
|
||||
tmp := concatenate(lparenNode, middleNode)
|
||||
to_add := concatenate(tmp, s)
|
||||
@@ -993,7 +993,7 @@ func thompson(re []postfixNode) (Reg, error) {
|
||||
}
|
||||
if c.startReps != 1 || c.endReps != 1 { // Must have a numeric specifier attached to it
|
||||
if c.endReps != -1 && c.endReps < c.startReps {
|
||||
return Reg{}, fmt.Errorf("Numeric specifier - start greater than end.")
|
||||
return Reg{}, fmt.Errorf("numeric specifier - start greater than end")
|
||||
}
|
||||
state := mustPop(&nfa)
|
||||
var stateToAdd *State = nil
|
||||
@@ -1024,7 +1024,7 @@ func thompson(re []postfixNode) (Reg, error) {
|
||||
}
|
||||
}
|
||||
if len(nfa) != 1 {
|
||||
return Reg{}, fmt.Errorf("Invalid Regex.")
|
||||
return Reg{}, fmt.Errorf("invalid regex")
|
||||
}
|
||||
|
||||
verifyLastStates(nfa)
|
||||
@@ -1040,11 +1040,11 @@ func thompson(re []postfixNode) (Reg, error) {
|
||||
func Compile(re string, flags ...ReFlag) (Reg, error) {
|
||||
nodes, err := shuntingYard(re, flags...)
|
||||
if err != nil {
|
||||
return Reg{}, fmt.Errorf("Error parsing regex: %w", err)
|
||||
return Reg{}, fmt.Errorf("error parsing regex: %w", err)
|
||||
}
|
||||
reg, err := thompson(nodes)
|
||||
if err != nil {
|
||||
return Reg{}, fmt.Errorf("Error compiling regex: %w", err)
|
||||
return Reg{}, fmt.Errorf("error compiling regex: %w", err)
|
||||
}
|
||||
return reg, nil
|
||||
}
|
||||
|
@@ -121,11 +121,11 @@ func newEscapedNode(c rune, inCharClass bool) (postfixNode, error) {
|
||||
toReturn.nodetype = CHARACTER
|
||||
toReturn.contents = append(toReturn.contents, '-')
|
||||
} else {
|
||||
return postfixNode{}, fmt.Errorf("Invalid escape character.")
|
||||
return postfixNode{}, fmt.Errorf("invalid escape character")
|
||||
}
|
||||
default: // None of the above - append it as a regular character
|
||||
if isNormalChar(c) { // Normal characters cannot be escaped
|
||||
return postfixNode{}, fmt.Errorf("Invalid escape character.")
|
||||
return postfixNode{}, fmt.Errorf("invalid escape character")
|
||||
}
|
||||
toReturn.nodetype = CHARACTER
|
||||
toReturn.contents = append(toReturn.contents, c)
|
||||
|
Reference in New Issue
Block a user