Loosened restrictions for concatenation - It's okay if one of the

elements is missing

LICENSE

@@ -1,11 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2025 Aadhavan Srinivasan
-
-All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Makefile

@@ -1,13 +1,9 @@
-.DEFAULT_GOAL := buildCmd
-.PHONY: fmt vet buildLib buildCmd test
+.DEFAULT_GOAL := build
+.PHONY: fmt vet build
 
 fmt:
 	go fmt ./...
 vet: fmt
 	go vet ./...
-buildLib: vet
+build: vet
 	go build -gcflags="-N -l" ./...
-buildCmd: buildLib
-	go build -C cmd/ -gcflags="-N -l" -o re ./...
-test: buildCmd
-	go test -v ./...

cmd/helpers.go

@@ -1,27 +0,0 @@
-package main
-
-import "slices"
-
-type character interface {
-	int | rune
-}
-
-// Returns all elements in slice A that are NOT in slice B
-func setDifference[T comparable](s1 []T, s2 []T) []T {
-	toReturn := make([]T, 0, len(s1))
-	for _, val := range s1 {
-		if !slices.Contains(s2, val) {
-			toReturn = append(toReturn, val)
-		}
-	}
-	return toReturn
-}
-
-// Generate numbers in a range - start (inclusive) to end (exclusive)
-func genRange[T character](start, end T) []T {
-	toRet := make([]T, end-start)
-	for i := start; i < end; i++ {
-		toRet[i-start] = i
-	}
-	return toRet
-}

go.mod

@@ -1,4 +1,4 @@
-module gitea.twomorecents.org/Rockingcool/kleingrep
+module re
 
 go 1.23.1
 

main.go

@@ -8,13 +8,11 @@ import (
 	"os"
 
 	"github.com/fatih/color"
-
-	reg "gitea.twomorecents.org/Rockingcool/kleingrep/regex"
 )
 
 func main() {
 	// Flags for the regex Compile function
-	flagsToCompile := make([]reg.ReFlag, 0)
+	flagsToCompile := make([]ReFlag, 0)
 
 	invertFlag := flag.Bool("v", false, "Invert match.")
 	// This flag has two 'modes':
@@ -31,10 +29,10 @@ func main() {
 
 	// These flags have to be passed to the Compile function
 	if *multiLineFlag {
-		flagsToCompile = append(flagsToCompile, reg.RE_MULTILINE, reg.RE_SINGLE_LINE)
+		flagsToCompile = append(flagsToCompile, RE_MULTILINE)
 	}
 	if *caseInsensitiveFlag {
-		flagsToCompile = append(flagsToCompile, reg.RE_CASE_INSENSITIVE)
+		flagsToCompile = append(flagsToCompile, RE_CASE_INSENSITIVE)
 	}
 
 	// -l and -o are mutually exclusive: -o overrides -l
@@ -78,7 +76,7 @@ func main() {
 	reader := bufio.NewReader(os.Stdin)
 	out := bufio.NewWriter(os.Stdout)
 
-	regComp, err := reg.Compile(re, flagsToCompile...)
+	regComp, err := Compile(re, flagsToCompile...)
 	if err != nil {
 		fmt.Println(err)
 		return
@@ -119,14 +117,14 @@ func main() {
 				panic(err)
 			}
 		}
-		matchIndices := make([]reg.Match, 0)
+		matchIndices := make([]Match, 0)
 		if matchNumFlagEnabled {
-			tmp, err := regComp.FindNthMatch(test_str, *matchNum)
+			tmp, err := FindNthMatch(regComp, test_str, *matchNum)
 			if err == nil {
 				matchIndices = append(matchIndices, tmp)
 			}
 		} else {
-			matchIndices = regComp.FindAllSubmatch(test_str)
+			matchIndices = FindAllMatches(regComp, test_str)
 		}
 
 		if *printMatchesFlag {
@@ -137,7 +135,7 @@ func main() {
 					fmt.Fprintf(out, "Line %d:\n", lineNum)
 				}
 				for _, m := range matchIndices {
-					fmt.Fprintf(out, "%s\n", m.String())
+					fmt.Fprintf(out, "%s\n", m.toString())
 				}
 				err := out.Flush()
 				if err != nil {
@@ -150,7 +148,7 @@ func main() {
 		// This should make checking O(1) instead of O(n)
 		indicesToPrint := new_uniq_arr[int]()
 		for _, idx := range matchIndices {
-			indicesToPrint.add(genRange(idx[0].StartIdx, idx[0].EndIdx)...)
+			indicesToPrint.add(genRange(idx[0].startIdx, idx[0].endIdx)...)
 		}
 		// If we are inverting, then we should print the indices which _didn't_ match
 		// in color.
@@ -185,9 +183,9 @@ func main() {
 			for i := range test_str {
 				inMatchIndex := false
 				for _, m := range matchIndices {
-					if i == m[0].StartIdx {
+					if i == m[0].startIdx {
 						fmt.Fprintf(out, "%s", *substituteText)
-						i = m[0].EndIdx
+						i = m[0].endIdx
 						inMatchIndex = true
 						break
 					}
@@ -203,7 +201,7 @@ func main() {
 					// Newline after every match - only if -o is enabled and -v is disabled.
 					if *onlyFlag && !(*invertFlag) {
 						for _, idx := range matchIndices {
-							if i+1 == idx[0].EndIdx { // End index is one more than last index of match
+							if i+1 == idx[0].endIdx { // End index is one more than last index of match
 								fmt.Fprintf(out, "\n")
 								break
 							}

matching.go

@@ -1,30 +1,24 @@
-package regex
+package main
 
 import (
 	"fmt"
 	"sort"
 )
 
-// A Match represents a match found by the regex in a given string.
-// It is represented as a list of groups, where the nth element contains
-// the contents of the nth capturing group. Note that the group may not be valid
-// (see [Group.IsValid]). The element at index 0 is known
-// as the 0-group, and represents the contents of the entire match.
-//
-// See [Reg.FindSubmatch] for an example.
+// a Match stores a slice of all the capturing groups in a match.
 type Match []Group
 
 // a Group represents a group. It contains the start index and end index of the match
 type Group struct {
-	StartIdx int
-	EndIdx   int
+	startIdx int
+	endIdx   int
 }
 
 func newMatch(size int) Match {
 	toRet := make([]Group, size)
 	for i := range toRet {
-		toRet[i].StartIdx = -1
-		toRet[i].EndIdx = -1
+		toRet[i].startIdx = -1
+		toRet[i].endIdx = -1
 	}
 	return toRet
 }
@@ -33,7 +27,7 @@ func newMatch(size int) Match {
 func (m Match) numValidGroups() int {
 	numValid := 0
 	for _, g := range m {
-		if g.StartIdx >= 0 && g.EndIdx >= 0 {
+		if g.startIdx >= 0 && g.endIdx >= 0 {
 			numValid++
 		}
 	}
@@ -41,60 +35,54 @@ func (m Match) numValidGroups() int {
 }
 
 // Returns a string containing the indices of all (valid) groups in the match
-func (m Match) String() string {
+func (m Match) toString() string {
 	var toRet string
 	for i, g := range m {
-		if g.IsValid() {
+		if g.isValid() {
 			toRet += fmt.Sprintf("Group %d\n", i)
-			toRet += g.String()
+			toRet += g.toString()
 			toRet += "\n"
 		}
 	}
 	return toRet
 }
 
-// String converts the Group into a string representation.
-func (idx Group) String() string {
-	return fmt.Sprintf("%d\t%d", idx.StartIdx, idx.EndIdx)
+// Converts the Group into a string representation:
+func (idx Group) toString() string {
+	return fmt.Sprintf("%d\t%d", idx.startIdx, idx.endIdx)
 }
 
-// Returns whether a group is valid (ie. whether it matched any text). It
-// simply ensures that both indices of the group are >= 0.
-func (g Group) IsValid() bool {
-	return g.StartIdx >= 0 && g.EndIdx >= 0
-}
-
-// Simple function, makes it easier to map this over a list of matches
-func getZeroGroup(m Match) Group {
-	return m[0]
+// Returns whether a group contains valid indices
+func (g Group) isValid() bool {
+	return g.startIdx >= 0 && g.endIdx >= 0
 }
 
 // takeZeroState takes the 0-state (if such a transition exists) for all states in the
 // given slice. It returns the resulting states. If any of the resulting states is a 0-state,
 // the second ret val is true.
 // If a state begins or ends a capturing group, its 'thread' is updated to contain the correct index.
-func takeZeroState(states []*nfaState, numGroups int, idx int) (rtv []*nfaState, isZero bool) {
+func takeZeroState(states []*State, numGroups int, idx int) (rtv []*State, isZero bool) {
 	for _, state := range states {
-		if len(state.transitions[epsilon]) > 0 {
-			for _, s := range state.transitions[epsilon] {
+		if len(state.transitions[EPSILON]) > 0 {
+			for _, s := range state.transitions[EPSILON] {
 				if s.threadGroups == nil {
 					s.threadGroups = newMatch(numGroups + 1)
 				}
 				copy(s.threadGroups, state.threadGroups)
 				if s.groupBegin {
-					s.threadGroups[s.groupNum].StartIdx = idx
+					s.threadGroups[s.groupNum].startIdx = idx
 					//					openParenGroups = append(openParenGroups, s.groupNum)
 				}
 				if s.groupEnd {
-					s.threadGroups[s.groupNum].EndIdx = idx
+					s.threadGroups[s.groupNum].endIdx = idx
 					//					closeParenGroups = append(closeParenGroups, s.groupNum)
 				}
 			}
-			rtv = append(rtv, state.transitions[epsilon]...)
+			rtv = append(rtv, state.transitions[EPSILON]...)
 		}
 	}
 	for _, state := range rtv {
-		if len(state.transitions[epsilon]) > 0 {
+		if len(state.transitions[EPSILON]) > 0 {
 			return rtv, true
 		}
 	}
@@ -105,21 +93,21 @@ func takeZeroState(states []*nfaState, numGroups int, idx int) (rtv []*nfaState,
 // from any of the given states, given the string and our position in it.
 // It uses the same algorithm to find zero-states as the one inside the loop,
 // so I should probably put it in a function.
-func zeroMatchPossible(str []rune, idx int, numGroups int, states ...*nfaState) bool {
+func zeroMatchPossible(str []rune, idx int, numGroups int, states ...*State) bool {
 	zeroStates, isZero := takeZeroState(states, numGroups, idx)
-	tempstates := make([]*nfaState, 0, len(zeroStates)+len(states))
+	tempstates := make([]*State, 0, len(zeroStates)+len(states))
 	tempstates = append(tempstates, states...)
 	tempstates = append(tempstates, zeroStates...)
 	num_appended := 0 // number of unique states addded to tempstates
 	for isZero == true {
 		zeroStates, isZero = takeZeroState(tempstates, numGroups, idx)
-		tempstates, num_appended = uniqueAppend(tempstates, zeroStates...)
+		tempstates, num_appended = unique_append(tempstates, zeroStates...)
 		if num_appended == 0 { // break if we haven't appended any more unique values
 			break
 		}
 	}
 	for _, state := range tempstates {
-		if state.isEmpty && (state.assert == noneAssert || state.checkAssertion(str, idx)) && state.isLast {
+		if state.isEmpty && (state.assert == NONE || state.checkAssertion(str, idx)) && state.isLast {
 			return true
 		}
 	}
@@ -130,17 +118,17 @@ func zeroMatchPossible(str []rune, idx int, numGroups int, states ...*nfaState)
 func pruneIndices(indices []Match) []Match {
 	// First, sort the slice by the start indices
 	sort.Slice(indices, func(i, j int) bool {
-		return indices[i][0].StartIdx < indices[j][0].StartIdx
+		return indices[i][0].startIdx < indices[j][0].startIdx
 	})
 	toRet := make([]Match, 0, len(indices))
 	current := indices[0]
 	for _, idx := range indices[1:] {
 		// idx doesn't overlap with current (starts after current ends), so add current to result
 		// and update the current.
-		if idx[0].StartIdx >= current[0].EndIdx {
+		if idx[0].startIdx >= current[0].endIdx {
 			toRet = append(toRet, current)
 			current = idx
-		} else if idx[0].EndIdx > current[0].EndIdx {
+		} else if idx[0].endIdx > current[0].endIdx {
 			// idx overlaps, but it is longer, so update current
 			current = idx
 		}
@@ -150,72 +138,36 @@ func pruneIndices(indices []Match) []Match {
 	return toRet
 }
 
-// Find returns the 0-group of the leftmost match of the regex in the given string.
-// An error value != nil indicates that no match was found.
-func (regex Reg) Find(str string) (Group, error) {
-	match, err := regex.FindNthMatch(str, 1)
-	if err != nil {
-		return Group{}, fmt.Errorf("no matches found")
-	}
-	return getZeroGroup(match), nil
-}
-
-// FindAll returns a slice containing all the 0-groups of the regex in the given string.
-// A 0-group represents the match without any submatches.
-func (regex Reg) FindAll(str string) []Group {
-	indices := regex.FindAllSubmatch(str)
-	zeroGroups := funcMap(indices, getZeroGroup)
-	return zeroGroups
-}
-
-// FindString returns the text of the leftmost match of the regex in the given string.
-// The return value will be an empty string in two situations:
+// FindString returns a _string_ containing the _text_ of the _leftmost_ match of
+// the regex, in the given string. The return value will be an empty string in two situations:
 //  1. No match was found
 //  2. The match was an empty string
-func (regex Reg) FindString(str string) string {
-	match, err := regex.FindNthMatch(str, 1)
+func FindString(regex Reg, str string) string {
+	match, err := FindNthMatch(regex, str, 1)
 	if err != nil {
 		return ""
 	}
-	zeroGroup := getZeroGroup(match)
-	return str[zeroGroup.StartIdx:zeroGroup.EndIdx]
-}
-
-// FindSubmatch returns the leftmost match of the regex in the given string, including
-// the submatches matched by capturing groups. The returned [Match] will always contain the same
-// number of groups. The validity of a group (whether or not it matched anything) can be determined with
-// [Group.IsValid], or by checking that both indices of the group are >= 0.
-// The second-return value is nil if no match was found.
-func (regex Reg) FindSubmatch(str string) (Match, error) {
-	match, err := regex.FindNthMatch(str, 1)
-	if err != nil {
-		return Match{}, fmt.Errorf("no match found")
-	} else {
-		return match, nil
-	}
+	return str[match[0].startIdx:match[0].endIdx]
 }
 
 // FindAllString is the 'all' version of FindString.
-// It returns a slice of strings containing the text of all matches of
-// the regex in the given string.
-func (regex Reg) FindAllString(str string) []string {
-	zerogroups := regex.FindAll(str)
-	matchStrs := funcMap(zerogroups, func(g Group) string {
-		return str[g.StartIdx:g.EndIdx]
-	})
-	return matchStrs
-}
+// It returns a _slice of strings_ containing the _text_ of _all_ matches of
+// the regex, in the given string.
+//func FindAllString(regex Reg, str []string) []string {
+//
+//}
 
-// FindNthMatch return the 'n'th match of the regex in the given string.
+// FindNthMatch finds the 'n'th match of the regex represented by the given start-state, with
+// the given string.
 // It returns an error (!= nil) if there are fewer than 'n' matches in the string.
-func (regex Reg) FindNthMatch(str string, n int) (Match, error) {
+func FindNthMatch(regex Reg, str string, n int) (Match, error) {
 	idx := 0
 	matchNum := 0
 	str_runes := []rune(str)
 	var matchFound bool
 	var matchIdx Match
 	for idx <= len(str_runes) {
-		matchFound, matchIdx, idx = findAllSubmatchHelper(regex.start, str_runes, idx, regex.numGroups)
+		matchFound, matchIdx, idx = findAllMatchesHelper(regex.start, str_runes, idx, regex.numGroups)
 		if matchFound {
 			matchNum++
 		}
@@ -224,18 +176,19 @@ func (regex Reg) FindNthMatch(str string, n int) (Match, error) {
 		}
 	}
 	// We haven't found the nth match after scanning the string - Return an error
-	return nil, fmt.Errorf("invalid match index - too few matches found")
+	return nil, fmt.Errorf("Invalid match index. Too few matches found.")
 }
 
-// FindAllSubmatch returns a slice of matches in the given string.
-func (regex Reg) FindAllSubmatch(str string) []Match {
+// FindAllMatches tries to find all matches of the regex represented by given start-state, with
+// the given string
+func FindAllMatches(regex Reg, str string) []Match {
 	idx := 0
 	str_runes := []rune(str)
 	var matchFound bool
 	var matchIdx Match
 	indices := make([]Match, 0)
 	for idx <= len(str_runes) {
-		matchFound, matchIdx, idx = findAllSubmatchHelper(regex.start, str_runes, idx, regex.numGroups)
+		matchFound, matchIdx, idx = findAllMatchesHelper(regex.start, str_runes, idx, regex.numGroups)
 		if matchFound {
 			indices = append(indices, matchIdx)
 		}
@@ -243,7 +196,6 @@ func (regex Reg) FindAllSubmatch(str string) []Match {
 	if len(indices) > 0 {
 		return pruneIndices(indices)
 	}
-
 	return indices
 }
 
@@ -252,13 +204,12 @@ func (regex Reg) FindAllSubmatch(str string) []Match {
 // the next search should start from.
 //
 //	Might return duplicates or overlapping indices, so care must be taken to prune the resulting array.
-func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups int) (bool, Match, int) {
+func findAllMatchesHelper(start *State, str []rune, offset int, numGroups int) (bool, Match, int) {
 	// Base case - exit if offset exceeds string's length
 	if offset > len(str) {
 		// The second value here shouldn't be used, because we should exit when the third return value is > than len(str)
 		return false, []Group{}, offset
 	}
-	resetThreads(start)
 
 	// Hold a list of match indices for the current run. When we
 	// can no longer find a match, the match with the largest range is
@@ -270,14 +221,14 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 	foundPath := false
 	startIdx := offset
 	endIdx := offset
-	currentStates := make([]*nfaState, 0)
-	tempStates := make([]*nfaState, 0) // Used to store states that should be used in next loop iteration
-	i := offset                        // Index in string
-	startingFrom := i                  // Store starting index
+	currentStates := make([]*State, 0)
+	tempStates := make([]*State, 0) // Used to store states that should be used in next loop iteration
+	i := offset                     // Index in string
+	startingFrom := i               // Store starting index
 
 	// If the first state is an assertion, makes sure the assertion
 	// is true before we do _anything_ else.
-	if start.assert != noneAssert {
+	if start.assert != NONE {
 		if start.checkAssertion(str, offset) == false {
 			i++
 			return false, []Group{}, i
@@ -296,7 +247,7 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 	start.threadGroups = newMatch(numGroups + 1)
 	// Check if the start state begins a group - if so, add the start index to our list
 	if start.groupBegin {
-		start.threadGroups[start.groupNum].StartIdx = i
+		start.threadGroups[start.groupNum].startIdx = i
 		//		tempIndices[start.groupNum].startIdx = i
 	}
 
@@ -306,7 +257,7 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 	for i < len(str) {
 		foundPath = false
 
-		zeroStates := make([]*nfaState, 0)
+		zeroStates := make([]*State, 0)
 		// Keep taking zero-states, until there are no more left to take
 		// Objective: If any of our current states have transitions to 0-states, replace them with the 0-state. Do this until there are no more transitions to 0-states, or there are no more unique 0-states to take.
 		zeroStates, isZero := takeZeroState(currentStates, numGroups, i)
@@ -314,21 +265,21 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 		num_appended := 0
 		for isZero == true {
 			zeroStates, isZero = takeZeroState(tempStates, numGroups, i)
-			tempStates, num_appended = uniqueAppend(tempStates, zeroStates...)
+			tempStates, num_appended = unique_append(tempStates, zeroStates...)
 			if num_appended == 0 { // Break if we haven't appended any more unique values
 				break
 			}
 		}
 
-		currentStates, _ = uniqueAppend(currentStates, tempStates...)
+		currentStates, _ = unique_append(currentStates, tempStates...)
 		tempStates = nil
 
 		// Take any transitions corresponding to current character
-		numStatesMatched := 0            // The number of states which had at least 1 match for this round
-		assertionFailed := false         // Whether or not an assertion failed for this round
-		lastStateInList := false         // Whether or not a last state was in our list of states
-		var lastStatePtr *nfaState = nil // Pointer to the last-state, if it was found
-		lastLookaroundInList := false    // Whether or not a last state (that is a lookaround) was in our list of states
+		numStatesMatched := 0         // The number of states which had at least 1 match for this round
+		assertionFailed := false      // Whether or not an assertion failed for this round
+		lastStateInList := false      // Whether or not a last state was in our list of states
+		var lastStatePtr *State = nil // Pointer to the last-state, if it was found
+		lastLookaroundInList := false // Whether or not a last state (that is a lookaround) was in our list of states
 		for _, state := range currentStates {
 			matches, numMatches := state.matchesFor(str, i)
 			if numMatches > 0 {
@@ -378,7 +329,7 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 		// 	b. Empty
 		// 	c. Doesn't assert anything
 		for _, s := range currentStates {
-			if s.isLast && s.isEmpty && s.assert == noneAssert {
+			if s.isLast && s.isEmpty && s.assert == NONE {
 				lastStatePtr = s
 				lastStateInList = true
 			}
@@ -394,7 +345,7 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 		// Check if we can find a zero-length match
 		if foundPath == false {
 			if ok := zeroMatchPossible(str, i, numGroups, currentStates...); ok {
-				if tempIndices[0].IsValid() == false {
+				if tempIndices[0].isValid() == false {
 					tempIndices[0] = Group{startIdx, startIdx}
 				}
 			}
@@ -404,16 +355,16 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 			startIdx++
 			//	i++
 			//			}
-			if tempIndices.numValidGroups() > 0 && tempIndices[0].IsValid() {
-				if tempIndices[0].StartIdx == tempIndices[0].EndIdx { // If we have a zero-length match, we have to shift the index at which we start. Otherwise we keep looking at the same paert of the string over and over.
-					return true, tempIndices, tempIndices[0].EndIdx + 1
+			if tempIndices.numValidGroups() > 0 && tempIndices[0].isValid() {
+				if tempIndices[0].startIdx == tempIndices[0].endIdx { // If we have a zero-length match, we have to shift the index at which we start. Otherwise we keep looking at the same paert of the string over and over.
+					return true, tempIndices, tempIndices[0].endIdx + 1
 				} else {
-					return true, tempIndices, tempIndices[0].EndIdx
+					return true, tempIndices, tempIndices[0].endIdx
 				}
 			}
 			return false, []Group{}, startIdx
 		}
-		currentStates = make([]*nfaState, len(tempStates))
+		currentStates = make([]*State, len(tempStates))
 		copy(currentStates, tempStates)
 		tempStates = nil
 
@@ -427,7 +378,7 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 	num_appended := 0 // Number of unique states addded to tempStates
 	for isZero == true {
 		zeroStates, isZero = takeZeroState(tempStates, numGroups, i)
-		tempStates, num_appended = uniqueAppend(tempStates, zeroStates...)
+		tempStates, num_appended = unique_append(tempStates, zeroStates...)
 		if num_appended == 0 { // Break if we haven't appended any more unique values
 			break
 		}
@@ -440,7 +391,7 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 		// 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 == noneAssert || state.checkAssertion(str, i) {
+			if state.assert == NONE || state.checkAssertion(str, i) {
 				for j := 1; j < numGroups+1; j++ {
 					tempIndices[j] = state.threadGroups[j]
 				}
@@ -451,10 +402,10 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 	}
 
 	if tempIndices.numValidGroups() > 0 {
-		if tempIndices[0].StartIdx == tempIndices[0].EndIdx { // If we have a zero-length match, we have to shift the index at which we start. Otherwise we keep looking at the same paert of the string over and over.
-			return true, tempIndices, tempIndices[0].EndIdx + 1
+		if tempIndices[0].startIdx == tempIndices[0].endIdx { // If we have a zero-length match, we have to shift the index at which we start. Otherwise we keep looking at the same paert of the string over and over.
+			return true, tempIndices, tempIndices[0].endIdx + 1
 		} else {
-			return true, tempIndices, tempIndices[0].EndIdx
+			return true, tempIndices, tempIndices[0].endIdx
 		}
 	}
 	if startIdx == startingFrom { // Increment starting index if we haven't moved in the string. Prevents us from matching the same part of the string over and over.

misc.go

@@ -1,4 +1,4 @@
-package regex
+package main
 
 import (
 	"slices"
@@ -8,16 +8,16 @@ import (
 var whitespaceChars = []rune{' ', '\t', '\n'}
 var digitChars = []rune{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
 var wordChars = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_")
-var lbracketRune rune = 0xF0002
-var rbracketRune rune = 0xF0003
-var anyCharRune rune = 0xF0004 // Represents any character - used for states where the allChars flag is on.
-var lparenRune rune = 0xF0005  // Parentheses in regex are concatenated with this - it acts as a pseudio-parentheses
-var rparenRune rune = 0xF0006
-var nonCapLparenRune rune = 0xF0007 // Represents a non-capturing group's LPAREN
-var escBackslashRune rune = 0xF0008 // Represents an escaped backslash
-var charRangeRune rune = 0xF0009    // Represents a character range
+var LBRACKET rune = 0xF0001
+var RBRACKET rune = 0xF0002
+var ANY_CHAR rune = 0xF0003    // Represents any character - used for states where the allChars flag is on.
+var LPAREN_CHAR rune = 0xF0004 // Parentheses in regex are concatenated with this - it acts as a pseudio-parentheses
+var RPAREN_CHAR rune = 0xF0005
+var NONCAPLPAREN_CHAR rune = 0xF0006 // Represents a non-capturing group's LPAREN
+var ESC_BACKSLASH rune = 0xF0007     // Represents an escaped backslash
+var CHAR_RANGE rune = 0xF0008        // Represents a character range
 
-var specialChars = []rune{'?', '*', '\\', '^', '$', '{', '}', '(', ')', '[', ']', '+', '|', '.', concatRune, '<', '>', lbracketRune, rbracketRune, nonCapLparenRune}
+var specialChars = []rune{'?', '*', '\\', '^', '$', '{', '}', '(', ')', '[', ']', '+', '|', '.', '~', '<', '>', LBRACKET, RBRACKET, NONCAPLPAREN_CHAR}
 
 // An interface for int and rune, which are identical
 type character interface {
@@ -48,9 +48,25 @@ func isNormalChar(c rune) bool {
 	return !slices.Contains(specialChars, c)
 }
 
+func assert(cond bool) {
+	if cond != true {
+		panic("Assertion Failed")
+	}
+}
+
+func deleteFromSlice[T comparable](slc []T, val T) []T {
+	toReturn := make([]T, 0, len(slc))
+	for _, v := range slc {
+		if v != val {
+			toReturn = append(toReturn, v)
+		}
+	}
+	return toReturn
+}
+
 // Ensure that the given elements are only appended to the given slice if they
 // don't already exist. Returns the new slice, and the number of unique items appended.
-func uniqueAppend[T comparable](slc []T, items ...T) ([]T, int) {
+func unique_append[T comparable](slc []T, items ...T) ([]T, int) {
 	num_appended := 0
 	for _, item := range items {
 		if !slices.Contains(slc, item) {
@@ -61,25 +77,6 @@ func uniqueAppend[T comparable](slc []T, items ...T) ([]T, int) {
 	return slc, num_appended
 }
 
-func uniqueAppendFunc[T any](slc []T, fn func(T, T) bool, items ...T) ([]T, int) {
-	toRet := make([]T, len(slc))
-	num_appended := 0
-	copy(toRet, slc)
-	for _, item := range items {
-		itemExists := false
-		for _, val := range slc {
-			if fn(item, val) {
-				itemExists = true
-			}
-		}
-		if !itemExists {
-			toRet = append(toRet, item)
-			num_appended++
-		}
-	}
-	return toRet, num_appended
-}
-
 // Returns true only if all the given elements are equal
 func allEqual[T comparable](items ...T) bool {
 	first := items[0]
@@ -91,9 +88,20 @@ func allEqual[T comparable](items ...T) bool {
 	return true
 }
 
+// Returns all elements in slice A that are NOT in slice B
+func setDifference[T comparable](s1 []T, s2 []T) []T {
+	toReturn := make([]T, 0, len(s1))
+	for _, val := range s1 {
+		if !slices.Contains(s2, val) {
+			toReturn = append(toReturn, val)
+		}
+	}
+	return toReturn
+}
+
 // Map function - convert a slice of T to a slice of V, based on a function
 // that maps a T to a V
-func funcMap[T, V any](slc []T, fn func(T) V) []V {
+func Map[T, V any](slc []T, fn func(T) V) []V {
 	toReturn := make([]V, len(slc))
 	for i, val := range slc {
 		toReturn[i] = fn(val)
@@ -103,7 +111,7 @@ func funcMap[T, V any](slc []T, fn func(T) V) []V {
 
 // Reduce function - reduces a slice of a type into a value of the type,
 // based on the given function.
-func funcReduce[T any](slc []T, fn func(T, T) T) T {
+func Reduce[T any](slc []T, fn func(T, T) T) T {
 	if len(slc) == 0 {
 		panic("Reduce on empty slice.")
 	}
@@ -116,30 +124,29 @@ func funcReduce[T any](slc []T, fn func(T, T) T) T {
 	return slc[0]
 }
 
-// Generate numbers in a range - start to end (both inclusive)
-func genRangeInclusive[T character](start, end T) []T {
-	toRet := make([]T, (end-start)+1)
-	for i := start; i <= end; i++ {
+// Generate numbers in a range - start (inclusive) to end (exclusive)
+func genRange[T character](start, end T) []T {
+	toRet := make([]T, end-start)
+	for i := start; i < end; i++ {
 		toRet[i-start] = i
 	}
 	return toRet
 }
 
-// Returns a rune-slice containing all possible cases of the given rune, given the
-// 'caseInsensitive' boolean variable.
-// If this variable is false, the rune is returned as-is, without modifications.
-// If it is true, then we return all possible cases of the
-// rune.
+// Returns a rune-slice containing all possible cases of the given rune.
 // At the moment, this includes:
 // 1. Upper case
 // 2. Lower case
 // 3. Title case
-func allCases(r rune, caseInsensitive bool) []rune {
-	if caseInsensitive {
-		return []rune{unicode.ToLower(r), unicode.ToUpper(r), unicode.ToTitle(r)}
-	} else {
-		return []rune{r}
-	}
+func allCases(r rune) []rune {
+	return []rune{unicode.ToLower(r), unicode.ToUpper(r), unicode.ToTitle(r)}
+}
+
+// Expands a slice to the given length
+func expandSlice[T any](slc []T, newSize int) []T {
+	toRet := make([]T, newSize)
+	copy(toRet, slc)
+	return toRet
 }
 
 func isHex(c rune) bool {

nfa.go

@@ -0,0 +1,335 @@
+package main
+
+import (
+	"slices"
+)
+
+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
+)
+
+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)
+	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
+	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
+	groupNum                   int              // Which capturing group the node starts / ends
+	// The following properties depend on the current match - I should think about resetting them for every match.
+	zeroMatchFound bool    // Whether or not the state has been used for a zero-length match - only relevant for zero states
+	threadGroups   []Group // Assuming that a state is part of a 'thread' in the matching process, this array stores the indices of capturing groups in the current thread. As matches are found for this state, its groups will be copied over.
+}
+
+// Clones the NFA starting from the given 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(state *State, cloneMap map[*State]*State) *State {
+	// Base case - if the clone exists in our map, return it.
+	if clone, exists := cloneMap[state]; exists {
+		return clone
+	}
+	if state == nil {
+		return nil
+	}
+	// 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{
+		content:         append([]int{}, state.content...),
+		isEmpty:         state.isEmpty,
+		isLast:          state.isLast,
+		output:          make([]*State, len(state.output)),
+		transitions:     make(map[int][]*State),
+		isKleene:        state.isKleene,
+		assert:          state.assert,
+		zeroMatchFound:  state.zeroMatchFound,
+		allChars:        state.allChars,
+		except:          append([]rune{}, state.except...),
+		lookaroundRegex: state.lookaroundRegex,
+		groupEnd:        state.groupEnd,
+		groupBegin:      state.groupBegin,
+		groupNum:        state.groupNum,
+	}
+	cloneMap[state] = clone
+	for i, s := range state.output {
+		if s == state {
+			clone.output[i] = clone
+		} else {
+			clone.output[i] = cloneStateHelper(s, cloneMap)
+		}
+	}
+	for k, v := range state.transitions {
+		clone.transitions[k] = make([]*State, len(v))
+		for i, s := range v {
+			if s == state {
+				clone.transitions[k][i] = clone
+			} else {
+				clone.transitions[k][i] = cloneStateHelper(s, cloneMap)
+			}
+		}
+	}
+	if state.lookaroundNFA == state {
+		clone.lookaroundNFA = clone
+	}
+	clone.lookaroundNFA = cloneStateHelper(state.lookaroundNFA, cloneMap)
+	return clone
+}
+
+// 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 {
+		return true
+	}
+	if s.assert == SOS {
+		return idx == 0
+	}
+	if s.assert == EOS {
+		// Index is at the end of the string, or it points to the last character which is a newline
+		return idx == len(str) || (idx == len(str)-1 && str[len(str)-1] == '\n')
+	}
+	if s.assert == WBOUND {
+		return isWordBoundary(str, idx)
+	}
+	if s.assert == NONWBOUND {
+		return !isWordBoundary(str, idx)
+	}
+	if s.isLookaround() {
+		// The process here is simple:
+		// 		1. Compile the regex stored in the state's contents.
+		// 		2. Run it on a subset of the test string, that ends after the current index in the string
+		// 		3. Based on the kind of lookaround (and the indices we get), determine what action to take.
+		startState := s.lookaroundNFA
+		var runesToMatch []rune
+		var strToMatch string
+		if s.assert == PLA || s.assert == NLA {
+			runesToMatch = str[idx:]
+		} else {
+			runesToMatch = str[:idx]
+		}
+
+		if len(runesToMatch) == 0 {
+			strToMatch = ""
+		} else {
+			strToMatch = string(runesToMatch)
+		}
+
+		matchIndices := FindAllMatches(Reg{startState, s.lookaroundNumCaptureGroups}, strToMatch)
+
+		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 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 matchIdx[0].endIdx == idx {
+					numMatchesFound++
+				}
+			}
+		}
+		if s.assert == PLA || s.assert == PLB { // Positive assertions want at least one match
+			return numMatchesFound > 0
+		}
+		if s.assert == NLA || s.assert == NLB { // Negative assertions only want zero matches
+			return numMatchesFound == 0
+		}
+	}
+	return true
+}
+
+// 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 {
+		return s.checkAssertion(str, idx)
+	}
+	if s.allChars {
+		return !slices.Contains(slices.Concat(notDotChars, s.except), str[idx]) // Return true only if the index isn't a 'notDotChar', or isn't one of the exception characters for the current node.
+	}
+	// Default - s.assert must be NONE
+	return slices.Contains(s.content, int(str[idx]))
+}
+
+func (s State) isLookaround() bool {
+	return s.assert == PLA || s.assert == PLB || s.assert == NLA || s.assert == NLB
+}
+
+// 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) {
+	// 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.checkAssertion(str, idx) == false {
+			return make([]*State, 0), -1
+		}
+	}
+	listTransitions := s.transitions[int(str[idx])]
+	for _, dest := range s.transitions[int(ANY_CHAR)] {
+		if !slices.Contains(slices.Concat(notDotChars, dest.except), str[idx]) {
+			// Add an allChar state to the list of matches if:
+			// 		a. The current character isn't a 'notDotChars' character. In single line mode, this includes newline. In multiline mode, it doesn't.
+			// 		b. The current character isn't the state's exception list.
+			listTransitions = append(listTransitions, dest)
+		}
+	}
+	numTransitions := len(listTransitions)
+	return listTransitions, numTransitions
+}
+
+type NFA struct {
+	start   State
+	outputs []State
+}
+
+// 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
+		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*
+		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 {
+				moreThanOneTrans = true
+			}
+		}
+		state.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 {
+			transitionDests = append(transitionDests, v...)
+		}
+		if allEqual(transitionDests...) {
+			state.isLast = true
+			return
+		}
+	}
+	if visited[state] == true {
+		return
+	}
+	visited[state] = true
+	for _, states := range state.transitions {
+		for i := range states {
+			if states[i] != state {
+				verifyLastStatesHelper(states[i], visited)
+			}
+		}
+	}
+}
+
+// verifyLastStates enables the 'isLast' flag for the leaf nodes (last states)
+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 {
+	if s1 == nil {
+		return s2
+	}
+	for i := range s1.output {
+		for _, c := range s2.content { // Create transitions for every element in s1's content to s2'
+			s1.output[i].transitions[c], _ = unique_append(s1.output[i].transitions[c], s2)
+		}
+	}
+	s1.output = s2.output
+	return s1
+}
+
+func kleene(s1 State) *State {
+	toReturn := &State{}
+	toReturn.transitions = make(map[int][]*State)
+	toReturn.content = newContents(EPSILON)
+	toReturn.isEmpty = true
+	toReturn.isKleene = true
+	toReturn.output = append(toReturn.output, toReturn)
+	for i := range s1.output {
+		for _, c := range toReturn.content {
+			s1.output[i].transitions[c], _ = unique_append(s1.output[i].transitions[c], toReturn)
+		}
+	}
+	for _, c := range s1.content {
+		toReturn.transitions[c], _ = unique_append(toReturn.transitions[c], &s1)
+	}
+	return toReturn
+}
+
+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,
+	// for any given transition, a state can only be mentioned once.
+	// For example, given the transition 'a', the state 's1' can only be mentioned once.
+	// This would lead to multiple instances of the same set of match indices, since both
+	// 's1' states would be considered to match.
+	for _, c := range s1.content {
+		toReturn.transitions[c], _ = unique_append(toReturn.transitions[c], s1)
+	}
+	for _, c := range s2.content {
+		toReturn.transitions[c], _ = unique_append(toReturn.transitions[c], s2)
+	}
+	toReturn.content = newContents(EPSILON)
+	toReturn.isEmpty = true
+
+	return toReturn
+}
+
+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
+	s3 := alternate(s1, s2)
+	return s3
+}
+
+// Creates and returns a new state with the 'default' values.
+func newState() State {
+	ret := State{
+		output:          make([]*State, 0),
+		transitions:     make(map[int][]*State),
+		assert:          NONE,
+		except:          append([]rune{}, 0),
+		lookaroundRegex: "",
+		groupEnd:        false,
+		groupBegin:      false,
+	}
+	ret.output = append(ret.output, &ret)
+	return ret
+}

postfixNode.go

@@ -1,8 +1,8 @@
-package regex
+package main
 
 import "fmt"
 
-type nodeType int
+type NodeType int
 
 // This is a slice containing all escapable characters that have special meaning.
 // Eg. \b is word boundary, \w is word character etc.
@@ -10,28 +10,28 @@ var escapedChars []rune = []rune("wWdDbBnaftrvsS0")
 
 // This is a list of the possible node types
 const (
-	characterNode nodeType = iota
-	charclassNode
-	pipeNode
-	concatenateNode
-	kleeneNode
-	questionNode
-	plusNode
-	assertionNode
-	lparenNode
-	rparenNode
+	CHARACTER NodeType = iota
+	CHARCLASS
+	PIPE
+	CONCATENATE
+	KLEENE
+	QUESTION
+	PLUS
+	ASSERTION
+	LPAREN
+	RPAREN
 )
 
 // Helper constants for lookarounds
-const positive = 1
-const negative = -1
-const lookahead = 1
-const lookbehind = -1
+const POSITIVE = 1
+const NEGATIVE = -1
+const LOOKAHEAD = 1
+const LOOKBEHIND = -1
 
-var infinite_reps int = -1 // Represents infinite reps eg. the end range in {5,}
+var INFINITE_REPS int = -1 // Represents infinite reps eg. the end range in {5,}
 // This represents a node in the postfix representation of the expression
 type postfixNode struct {
-	nodetype       nodeType
+	nodetype       NodeType
 	contents       []rune        // Contents of the node
 	startReps      int           // Minimum number of times the node should be repeated - used with numeric specifiers
 	endReps        int           // Maximum number of times the node should be repeated - used with numeric specifiers
@@ -49,12 +49,12 @@ type postfixNode struct {
 // it will not match.
 func newCharClassNode(nodes []postfixNode, negated bool) postfixNode {
 	rtv := postfixNode{}
-	rtv.nodetype = charclassNode
+	rtv.nodetype = CHARCLASS
 	rtv.startReps = 1
 	rtv.endReps = 1
 	if negated {
-		rtv.nodetype = characterNode
-		rtv.contents = []rune{anyCharRune}
+		rtv.nodetype = CHARACTER
+		rtv.contents = []rune{ANY_CHAR}
 		rtv.allChars = true
 		rtv.except = nodes
 	} else {
@@ -70,74 +70,64 @@ func newEscapedNode(c rune, inCharClass bool) (postfixNode, error) {
 	toReturn.endReps = 1
 	switch c {
 	case 's': // Whitespace
-		toReturn.nodetype = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, whitespaceChars...)
 	case 'S': // Non-whitespace
 		toReturn = newPostfixDotNode()
 		toReturn.except = append([]postfixNode{}, newPostfixNode(whitespaceChars...))
 	case 'd': // Digits
-		toReturn.nodetype = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, digitChars...)
 	case 'D': // Non-digits
 		toReturn = newPostfixDotNode()
 		toReturn.except = append([]postfixNode{}, newPostfixNode(digitChars...))
 	case 'w': // word character
-		toReturn.nodetype = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, wordChars...)
 	case 'W': // Non-word character
 		toReturn = newPostfixDotNode()
 		toReturn.except = append([]postfixNode{}, newPostfixNode(wordChars...))
 	case 'b', 'B':
 		if c == 'b' && inCharClass {
-			toReturn.nodetype = characterNode
+			toReturn.nodetype = CHARACTER
 			toReturn.contents = append(toReturn.contents, rune(8))
 		} else {
-			toReturn.nodetype = assertionNode
-			toReturn.contents = append(toReturn.contents, c)
-		}
-		if c == 'B' && inCharClass { // Invalid
-			return postfixNode{}, fmt.Errorf("word boundaries are not allowed in character class")
-		}
-	case 'A', 'z': // A is start of input, z is end of input (regardless of RE_MULTILINE)
-		if inCharClass {
-			return postfixNode{}, fmt.Errorf("input boundaries are not allowed in character class")
-		} else {
-			toReturn.nodetype = assertionNode
+			toReturn.nodetype = ASSERTION
 			toReturn.contents = append(toReturn.contents, c)
 		}
 	case 'n': // Newline character
-		toReturn.nodetype = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, '\n')
 	case '0': // NULL character
-		toReturn.nodetype = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, rune(0))
 	case 'a': // Bell character
-		toReturn.nodetype = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, rune(7))
 	case 'f': // Form feed character
-		toReturn.nodetype = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, rune(12))
 	case 't': // Horizontal tab character
-		toReturn.nodetype = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, rune(9))
 	case 'r': // Carriage return
-		toReturn.nodetype = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, rune(13))
 	case 'v': // Vertical tab
-		toReturn.nodetype = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, rune(11))
 	case '-': // Literal hyphen - only in character class
 		if inCharClass {
-			toReturn.nodetype = characterNode
+			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 = characterNode
+		toReturn.nodetype = CHARACTER
 		toReturn.contents = append(toReturn.contents, c)
 	}
 	return toReturn, nil
@@ -152,37 +142,37 @@ func newPostfixNode(contents ...rune) postfixNode {
 	to_return.startReps = 1
 	to_return.endReps = 1
 	if len(contents) > 1 { // If the node has more than element, it must be a character class - the type must be CHARACTER
-		to_return.nodetype = characterNode
+		to_return.nodetype = CHARACTER
 		to_return.contents = contents
 	} else { // Node has one element, could be anything
 		switch contents[0] {
 		case '+':
-			to_return.nodetype = plusNode
+			to_return.nodetype = PLUS
 		case '?':
-			to_return.nodetype = questionNode
+			to_return.nodetype = QUESTION
 		case '*':
-			to_return.nodetype = kleeneNode
+			to_return.nodetype = KLEENE
 		case '|':
-			to_return.nodetype = pipeNode
-		case concatRune:
-			to_return.nodetype = concatenateNode
+			to_return.nodetype = PIPE
+		case CONCAT:
+			to_return.nodetype = CONCATENATE
 		case '^', '$':
-			to_return.nodetype = assertionNode
+			to_return.nodetype = ASSERTION
 		case '(':
-			to_return.nodetype = lparenNode
+			to_return.nodetype = LPAREN
 		case ')':
-			to_return.nodetype = rparenNode
+			to_return.nodetype = RPAREN
 		default:
-			to_return.nodetype = characterNode
+			to_return.nodetype = CHARACTER
 		}
 		to_return.contents = append(to_return.contents, contents...)
 
 		// Special cases for LPAREN and RPAREN - they have special characters defined for them
-		if to_return.nodetype == lparenNode {
-			to_return.contents = []rune{lparenRune}
+		if to_return.nodetype == LPAREN {
+			to_return.contents = []rune{LPAREN_CHAR}
 		}
-		if to_return.nodetype == rparenNode {
-			to_return.contents = []rune{rparenRune}
+		if to_return.nodetype == RPAREN {
+			to_return.contents = []rune{RPAREN_CHAR}
 		}
 	}
 	return to_return
@@ -193,9 +183,9 @@ func newPostfixDotNode() postfixNode {
 	toReturn := postfixNode{}
 	toReturn.startReps = 1
 	toReturn.endReps = 1
-	toReturn.nodetype = characterNode
+	toReturn.nodetype = CHARACTER
 	toReturn.allChars = true
-	toReturn.contents = []rune{anyCharRune}
+	toReturn.contents = []rune{ANY_CHAR}
 	return toReturn
 }
 
@@ -204,7 +194,7 @@ func newPostfixCharNode(contents ...rune) postfixNode {
 	toReturn := postfixNode{}
 	toReturn.startReps = 1
 	toReturn.endReps = 1
-	toReturn.nodetype = characterNode
+	toReturn.nodetype = CHARACTER
 	toReturn.contents = append(toReturn.contents, contents...)
 	return toReturn
 }

range2regex.go

@@ -1,11 +1,9 @@
-package regex
+package main
 
 import (
 	"fmt"
 	"math"
-	"slices"
 	"strconv"
-	"strings"
 )
 
 type numRange struct {
@@ -46,11 +44,11 @@ func intToSlc(val int) []int {
 	return toRet
 }
 
-func range2regex(start int, end int) (string, error) {
+func range2regex(start int, end int) string {
 	rangeStart := start
 	rangeEnd := end
 	if rangeStart > rangeEnd {
-		return "", fmt.Errorf("numeric range start greater than range end")
+		panic("Range start greater than range end.")
 	}
 
 	ranges := make([]numRange, 0)
@@ -101,39 +99,28 @@ func range2regex(start int, end int) (string, error) {
 	// Last range - tmp to rangeEnd
 	ranges = append(ranges, numRange{tmp, rangeEnd})
 
-	regexSlice := make([]string, 0)
+	regex := "("
 	// Generate the regex
-	for _, rg := range ranges {
-		tmpStr := ""
-		tmpStr += string(nonCapLparenRune)
+	for i, rg := range ranges {
+		if i > 0 {
+			regex += "|"
+		}
+		regex += "("
 		startSlc := intToSlc(rg.start)
 		endSlc := intToSlc(rg.end)
 		if len(startSlc) != len(endSlc) {
-			return "", fmt.Errorf("Error parsing numeric range")
+			panic("Ranges have unequal lengths.")
 		}
 		for i := range startSlc {
 			if startSlc[i] == endSlc[i] {
-				tmpStr += string(rune(startSlc[i] + 48)) // '0' is ascii value 48, 1 is 49 etc. To convert the digit to its character form, we can just add 48.
+				regex += string(rune(startSlc[i] + 48)) // '0' is ascii value 48, 1 is 49 etc. To convert the digit to its character form, we can just add 48.
 			} else {
-				tmpStr += fmt.Sprintf("%c%c-%c%c", lbracketRune, rune(startSlc[i]+48), rune(endSlc[i]+48), rbracketRune)
+				regex += fmt.Sprintf("[%c-%c]", rune(startSlc[i]+48), rune(endSlc[i]+48))
 			}
 		}
-		tmpStr += ")"
-		regexSlice = append(regexSlice, tmpStr)
+		regex += ")"
 	}
-	// Each element of the slice represents one 'group'. Taking 0-255 as an example, the elements would be:
-	// 	1. 0-9
-	// 	2. 10-99
-	// 	3. 100-199
-	// 	4. 200-249
-	// 	5. 250-255
-	//
-	// The reason this is reversed before joining it, is because it is incompatible with the PCRE rule for matching.
-	// The PCRE rule specifies that the left-branch of an alternation is preferred. Even though this engine uses the POSIX
-	// rule at the moment (which prefers the longest match regardless of the order of the alternation), reversing the string
-	// has no downsides. It doesn't affect POSIX matching, and it will reduce my burden if I decide to switch to PCRE matching.
-	slices.Reverse(regexSlice)
-	regex := string(nonCapLparenRune) + strings.Join(regexSlice, "|") + ")"
-	return regex, nil
+	regex += ")"
+	return regex
 
 }

re_test.go

@@ -0,0 +1,371 @@
+package main
+
+import (
+	"fmt"
+	"slices"
+	"testing"
+)
+
+var reTests = []struct {
+	re     string
+	flags  []ReFlag
+	str    string
+	result []Group // Stores all zero-groups in the match
+}{
+	{"a", nil, "abc", []Group{{0, 1}}},
+	{"a", nil, "bca", []Group{{2, 3}}},
+	{"l", nil, "ggllgg", []Group{{2, 3}, {3, 4}}},
+	{"(b|c)", nil, "abdceb", []Group{{1, 2}, {3, 4}, {5, 6}}},
+	{"a+", nil, "brerereraaaaabbbbb", []Group{{8, 13}}},
+	{"ab+", nil, "qweqweqweaqweqweabbbbbr", []Group{{16, 22}}},
+	{"(b|c|A)", nil, "ooaoobocA", []Group{{5, 6}, {7, 8}, {8, 9}}},
+	{"ab*", nil, "a", []Group{{0, 1}}},
+	{"ab*", nil, "abb", []Group{{0, 3}}},
+	{"a*b", nil, "aaab", []Group{{0, 4}}},
+	{"a*b", nil, "qwqw", []Group{}},
+	{"(abc)*", nil, "abcabcabc", []Group{{0, 9}, {9, 9}}},
+	{"((abc)|(def))*", nil, "abcdef", []Group{{0, 6}, {6, 6}}},
+	{"(abc)*|(def)*", nil, "abcdef", []Group{{0, 3}, {3, 6}, {6, 6}}},
+	{"b*a*a", nil, "bba", []Group{{0, 3}}},
+	{"(ab)+", nil, "abcabddd", []Group{{0, 2}, {3, 5}}},
+	{"a(b(c|d)*)*", nil, "abccbd", []Group{{0, 6}}},
+	{"a(b|c)*d+", nil, "abccdd", []Group{{0, 6}}},
+	{"a*", nil, "", []Group{{0, 0}}},
+	{"a|b", nil, "c", []Group{}},
+	{"(a|b)*c", nil, "aabbc", []Group{{0, 5}}},
+	{"a(b|b)", nil, "ab", []Group{{0, 2}}},
+	{"a*", nil, "aaaaaaaa", []Group{{0, 8}, {8, 8}}},
+
+	{"ab?", nil, "ab", []Group{{0, 2}}},
+	{"a?b", nil, "ab", []Group{{0, 2}}},
+	{"a?", nil, "", []Group{{0, 0}}},
+	{"a?b?c", nil, "a", []Group{}},
+	{"a?b?c?", nil, "ab", []Group{{0, 2}, {2, 2}}},
+	{"a?b?c?", nil, "ac", []Group{{0, 2}, {2, 2}}},
+	{"a?b?c", nil, "abc", []Group{{0, 3}}},
+	{"a?b?c", nil, "acb", []Group{{0, 2}}},
+
+	{"[abc]", nil, "defadefbdefce", []Group{{3, 4}, {7, 8}, {11, 12}}},
+	{"[ab]c", nil, "ab", []Group{}},
+	{"g[ab]c", nil, "gac", []Group{{0, 3}}},
+	{"g[ab]c", nil, "gbc", []Group{{0, 3}}},
+	{"g[ab]c", nil, "gc", []Group{}},
+	{"g[ab]c", nil, "gfc", []Group{}},
+	{"[ab]*", nil, "aabbbabaababab", []Group{{0, 14}, {14, 14}}},
+	{"[ab]+", nil, "aabbbablaababab", []Group{{0, 7}, {8, 15}}},
+	{"[Ff]r[Uu]it", nil, "fruit", []Group{{0, 5}}},
+	{"[Ff]r[Uu]it", nil, "FrUit", []Group{{0, 5}}},
+	{"[Ff]r[Uu|]it", nil, "Fr|it", []Group{{0, 5}}},
+	{"[Ff]r([Uu]|[pP])it", nil, "Frpit", []Group{{0, 5}}},
+	{"[Ff]r[Uu]|[pP]it", nil, "Frpit", []Group{{2, 5}}},
+	{"[a-zA-Z]+", nil, "Hello, how is it going?", []Group{{0, 5}, {7, 10}, {11, 13}, {14, 16}, {17, 22}}},
+
+	{".+", nil, "Hello, how is it going?", []Group{{0, 23}}},
+	{"a.", nil, "a ", []Group{{0, 2}}},
+	{"a.b", nil, "a/b", []Group{{0, 3}}},
+	{".", nil, "a ", []Group{{0, 1}, {1, 2}}},
+	{"a.", nil, "a ", []Group{{0, 2}}},
+	{".+b", nil, "abc", []Group{{0, 2}}},
+
+	{`\d`, nil, "1a0a3s'''34343s", []Group{{0, 1}, {2, 3}, {4, 5}, {9, 10}, {10, 11}, {11, 12}, {12, 13}, {13, 14}}},
+	{`\\`, nil, `a\b\c\qwe\`, []Group{{1, 2}, {3, 4}, {5, 6}, {9, 10}}},
+	{`\W`, nil, `"Hello", he said. How are you doing?`, []Group{{0, 1}, {6, 7}, {7, 8}, {8, 9}, {11, 12}, {16, 17}, {17, 18}, {21, 22}, {25, 26}, {29, 30}, {35, 36}}},
+	{`\w`, nil, ";';';';';'qwe12", []Group{{10, 11}, {11, 12}, {12, 13}, {13, 14}, {14, 15}}},
+	{`\s`, nil, "a b c 	d", []Group{{1, 2}, {3, 4}, {5, 6}, {6, 7}}},
+	{`\<`, nil, "<HTML><body>", []Group{{0, 1}, {6, 7}}},
+	{`\(.+\)`, nil, "Not (paranthesized), (so) is (this) not", []Group{{4, 35}}},
+
+	{"[^abc]+", nil, "qarbtopsaplpclkpasdmb prejip0r,p", []Group{{0, 1}, {2, 3}, {4, 8}, {9, 12}, {13, 16}, {17, 20}, {21, 32}}},
+	{"[^a]+", nil, "qqqaq", []Group{{0, 3}, {4, 5}}},
+	{"[^0-9]+", nil, "a1b2c3dd", []Group{{0, 1}, {2, 3}, {4, 5}, {6, 8}}},
+	{"[^abc]+", nil, "ababababbababaccacacacaca", []Group{}},
+	{`\[`, nil, "a[b[c[]]]", []Group{{1, 2}, {3, 4}, {5, 6}}},
+	{`\([^)]+\)`, nil, "Not (paranthesized), (so) is (this) not", []Group{{4, 19}, {21, 25}, {29, 35}}},
+
+	{"^ab", nil, "ab bab", []Group{{0, 2}}},
+	{"^aaaa^", nil, "aaaaaaaa", []Group{}},
+	{"^([bB][Gg])", nil, "bG", []Group{{0, 2}}},
+	{"b$", nil, "ba", []Group{}},
+	{"(boy|girl)$", nil, "girlf", []Group{}},
+	{`\bint\b`, nil, "print int integer", []Group{{6, 9}}},
+	{`int\b`, nil, "ints", []Group{}},
+	{`int(\b|a)`, nil, "inta", []Group{{0, 4}}},
+	{`\b\d+\b`, nil, "511 a3 43", []Group{{0, 3}, {7, 9}}},
+	{`\Bint\B`, nil, "prints int integer print", []Group{{2, 5}}},
+	{`^`, nil, "5^3^2", []Group{{0, 0}}},
+	{`\^`, nil, "5^3^2", []Group{{1, 2}, {3, 4}}},
+	{`pool$`, nil, "pool carpool", []Group{{8, 12}}},
+	{`^int$`, nil, "print int integer", []Group{}},
+	{`^int$`, nil, "int", []Group{{0, 3}}},
+	{`b*`, nil, "aaaaaaaaaaqweqwe", []Group{{0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}, {9, 9}, {10, 10}, {11, 11}, {12, 12}, {13, 13}, {14, 14}, {15, 15}, {16, 16}}},
+
+	{"a{4}", nil, "aabaaa", []Group{}},
+	{"ab{5}", nil, "abbbbbab", []Group{{0, 6}}},
+	{"(a|b){3,4}", nil, "aba", []Group{{0, 3}}},
+	{"(a|b){3,4}", nil, "ababaa", []Group{{0, 4}}},
+	{"(bc){5,}", nil, "bcbcbcbcbcbcbcbc", []Group{{0, 16}}},
+	{`\d{3,4}`, nil, "1209", []Group{{0, 4}}},
+	{`\d{3,4}`, nil, "109", []Group{{0, 3}}},
+	{`\d{3,4}`, nil, "5", []Group{}},
+	{`\d{3,4}`, nil, "123135", []Group{{0, 4}}},
+	{`\d{3,4}`, nil, "89a-0", []Group{}},
+	{`\d{3,4}`, nil, "ababab555", []Group{{6, 9}}},
+	{`\bpaint\b`, nil, "paints", []Group{}},
+	{`\b\w{5}\b`, nil, "paint", []Group{{0, 5}}},
+	{`[^\w]`, nil, "abcdef1230[]qq';;'", []Group{{10, 11}, {11, 12}, {14, 15}, {15, 16}, {16, 17}, {17, 18}}},
+	{`[^\W]`, nil, "abcdef1230[]qq';;'", []Group{{0, 1}, {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8}, {8, 9}, {9, 10}, {12, 13}, {13, 14}}},
+	{`[\[\]]`, nil, "a[b[l]]", []Group{{1, 2}, {3, 4}, {5, 6}, {6, 7}}},
+
+	// Unicode tests
+	{`.+`, nil, "úïäö´«åæïëòöê»éãçâï«úïòíñ", []Group{{0, 25}}},
+	{`a.b`, nil, "a²b", []Group{{0, 3}}},
+	{`[^a]+`, nil, "úïäö´«åæïëòöê»éãçâï«úïòíñ", []Group{{0, 25}}},
+
+	// Fun experiment - AI-generated tests
+	{"(abc|def|ghi)", nil, "abcdefg", []Group{{0, 3}, {3, 6}}},
+	{"a(b|c)d", nil, "abcd", []Group{}},
+	{"a(b|c)*d", nil, "abcbcd", []Group{{0, 6}}},
+	{"a(b|c)+d", nil, "abcbcd", []Group{{0, 6}}},
+	{"a(b|c)?d", nil, "abd", []Group{{0, 3}}},
+	{".+", nil, "hello world", []Group{{0, 11}}},
+	{"a.b", nil, "aXb", []Group{{0, 3}}},
+	{"a.*b", nil, "aXb", []Group{{0, 3}}},
+	{"a.{2,3}b", nil, "aXXb", []Group{{0, 4}}},
+	{"a.{2,}b", nil, "aXXXb", []Group{{0, 5}}},
+	{"a.{0,3}b", nil, "ab", []Group{{0, 2}}},
+	{"[abc]+", nil, "abcabc", []Group{{0, 6}}},
+	{"[a-zA-Z]+", nil, "HelloWorld", []Group{{0, 10}}},
+	{"[^abc]+", nil, "defghi", []Group{{0, 6}}},
+	{"^hello", nil, "hello world", []Group{{0, 5}}},
+	{"world$", nil, "hello world", []Group{{6, 11}}},
+	{`\bhello\b`, nil, "hello world", []Group{{0, 5}}},
+	{`\Bhello\B`, nil, "hello world", []Group{}},
+	{"(hello|world)", nil, "hello world", []Group{{0, 5}, {6, 11}}},
+	{"(hello|world)+", nil, "hello world", []Group{{0, 5}, {6, 11}}},
+	{"(hello|world)*", nil, "hello world", []Group{{0, 5}, {5, 5}, {6, 11}, {11, 11}}},
+	{"(hello|world)?", nil, "hello world", []Group{{0, 5}, {5, 5}, {6, 11}, {11, 11}}},
+	{"ú.+ï", nil, "úïäö´«åæïëòöê»éãçâï«úïòíñ", []Group{{0, 22}}},
+	{"(?=hello)", nil, "hello world", []Group{{0, 0}}},
+	{"(?!hello)", nil, "hello world", []Group{{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}, {9, 9}, {10, 10}, {11, 11}}},
+	{"(?<=hello)", nil, "hello world", []Group{{5, 5}}},
+	{"(?<!hello)", nil, "hello world", []Group{{0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {6, 6}, {7, 7}, {8, 8}, {9, 9}, {10, 10}, {11, 11}}},
+	{"^((3[7-9])|([4-9][0-9])|([1-9][0-9][0-9])|(1000))$", nil, "40", []Group{{0, 2}}},
+	{"^((3[7-9])|([4-9][0-9])|([1-9][0-9][0-9])|(1000))$", nil, "040", []Group{}},
+	{"^((3[7-9])|([4-9][0-9])|([1-9][0-9][0-9])|(1000))$", nil, "400", []Group{{0, 3}}},
+	{"^((3[7-9])|([4-9][0-9])|([1-9][0-9][0-9])|(1000))$", nil, "4000", []Group{}},
+	{"a{1,3}", nil, "aaaaa", []Group{{0, 3}, {3, 5}}},
+	{`\\[ab\\]`, nil, "a", []Group{}},
+	{`\\[ab\\]`, nil, `\a`, []Group{{0, 2}}},
+
+	// Lookaround tests
+	{"(?<=bo)y", nil, "boy", []Group{{2, 3}}},
+	{"bo(?=y)", nil, "boy", []Group{{0, 2}}},
+	{"(?<=f)f+(?=f)", nil, "fffff", []Group{{1, 4}}},
+	{"(?<=f)f+(?=f)", nil, "fffffa", []Group{{1, 4}}},
+
+	// Test cases from Python's RE test suite
+	{`[\1]`, nil, "\x01", []Group{{0, 1}}},
+
+	{`\0`, nil, "\x00", []Group{{0, 1}}},
+	{`[\0a]`, nil, "\x00", []Group{{0, 1}}},
+	{`[\0a]`, nil, "\x00", []Group{{0, 1}}},
+	{`[a\0]`, nil, "\x00", []Group{{0, 1}}},
+	{`[^a\0]`, nil, "\x00", []Group{}},
+
+	{`\a[\b]\f\n\r\t\v`, nil, "\a\b\f\n\r\t\v", []Group{{0, 7}}},
+	{`[\a][\b][\f][\n][\r][\t][\v]`, nil, "\a\b\f\n\r\t\v", []Group{{0, 7}}},
+	{`\u`, nil, "", nil},
+	{`\xff`, nil, "ÿ", []Group{{0, 1}}},
+	{`\x00ffffffffffffff`, nil, "\xff", []Group{}},
+	{`\x00f`, nil, "\x0f", []Group{}},
+	{`\x00fe`, nil, "\xfe", []Group{}},
+	{`^\w+=(\\[\000-\277]|[^\n\\])*`, nil, "SRC=eval.c g.c blah blah blah \\\\\n\tapes.c", []Group{{0, 32}}},
+
+	{`a.b`, nil, `acb`, []Group{{0, 3}}},
+	{`a.b`, nil, "a\nb", []Group{}},
+	{`a.*b`, nil, "acc\nccb", []Group{}},
+	{`a.{4,5}b`, nil, "acc\nccb", []Group{}},
+	{`a.b`, nil, "a\rb", []Group{{0, 3}}},
+	{`a.b`, []ReFlag{RE_MULTILINE}, "a\nb", []Group{{0, 3}}},
+	{`a.*b`, []ReFlag{RE_MULTILINE}, "acc\nccb", []Group{{0, 7}}},
+	{`a.{4,5}b`, []ReFlag{RE_MULTILINE}, "acc\nccb", []Group{{0, 7}}},
+
+	{`)`, nil, ``, nil},
+	{`^$`, nil, ``, []Group{{0, 0}}},
+	{`abc`, nil, `abc`, []Group{{0, 3}}},
+	{`abc`, nil, `xbc`, []Group{}},
+	{`abc`, nil, `axc`, []Group{}},
+	{`abc`, nil, `abx`, []Group{}},
+	{`abc`, nil, `xabcy`, []Group{{1, 4}}},
+	{`abc`, nil, `ababc`, []Group{{2, 5}}},
+	{`ab*c`, nil, `abc`, []Group{{0, 3}}},
+	{`ab*bc`, nil, `abc`, []Group{{0, 3}}},
+	{`ab*bc`, nil, `abbc`, []Group{{0, 4}}},
+	{`ab*bc`, nil, `abbbbc`, []Group{{0, 6}}},
+	{`ab+bc`, nil, `abbc`, []Group{{0, 4}}},
+	{`ab+bc`, nil, `abc`, []Group{}},
+	{`ab+bc`, nil, `abq`, []Group{}},
+	{`ab+bc`, nil, `abbbbc`, []Group{{0, 6}}},
+	{`ab?bc`, nil, `abbc`, []Group{{0, 4}}},
+	{`ab?bc`, nil, `abc`, []Group{{0, 3}}},
+	{`ab?bc`, nil, `abbbbc`, []Group{}},
+	{`ab?c`, nil, `abc`, []Group{{0, 3}}},
+	{`^abc$`, nil, `abc`, []Group{{0, 3}}},
+	{`^abc$`, nil, `abcc`, []Group{}},
+	{`^abc`, nil, `abcc`, []Group{{0, 3}}},
+	{`^abc$`, nil, `aabc`, []Group{}},
+	{`abc$`, nil, `aabc`, []Group{{1, 4}}},
+	{`^`, nil, `abc`, []Group{{0, 0}}},
+	{`$`, nil, `abc`, []Group{{3, 3}}},
+	{`a.c`, nil, `abc`, []Group{{0, 3}}},
+	{`a.c`, nil, `axc`, []Group{{0, 3}}},
+	{`a.*c`, nil, `axyzc`, []Group{{0, 5}}},
+	{`a.*c`, nil, `axyzd`, []Group{}},
+	{`a[bc]d`, nil, `abc`, []Group{}},
+	{`a[bc]d`, nil, `abd`, []Group{{0, 3}}},
+	{`a[b-d]e`, nil, `abd`, []Group{}},
+	{`a[b-d]e`, nil, `ace`, []Group{{0, 3}}},
+	{`a[b-d]`, nil, `aac`, []Group{{1, 3}}},
+	{`a[-b]`, nil, `a-`, []Group{{0, 2}}}, // If a character class has a hyphen without a start or end character, it is treated as a literal hyphen
+	{`a[\-b]`, nil, `a-`, []Group{{0, 2}}},
+	{`a[b-]`, nil, `a-`, []Group{{0, 2}}}, // If a character class has a hyphen without a start or end character, it is treated as a literal hyphen
+
+	{`a[]b`, nil, `-`, nil},
+	{`a[`, nil, `-`, nil},
+	{`a\`, nil, `-`, nil},
+	{`abc)`, nil, `-`, nil},
+	{`(abc`, nil, `-`, nil},
+	{`a]`, nil, `a]`, []Group{{0, 2}}},
+	{`a[]]b`, nil, `a]b`, []Group{{0, 3}}},
+	{`a[\]]b`, nil, `a]b`, []Group{{0, 3}}},
+	{`a[^bc]d`, nil, `aed`, []Group{{0, 3}}},
+	{`a[^bc]d`, nil, `abd`, []Group{}},
+	{`a[^-b]c`, nil, `adc`, []Group{{0, 3}}},
+	{`a[^-b]c`, nil, `a-c`, []Group{}},
+	{`a[^]b]c`, nil, `a]c`, []Group{}},
+	{`a[^]b]c`, nil, `adc`, []Group{{0, 3}}},
+	{`\ba\b`, nil, `a-`, []Group{{0, 1}}},
+	{`\ba\b`, nil, `-a`, []Group{{1, 2}}},
+	{`\ba\b`, nil, `-a-`, []Group{{1, 2}}},
+	{`\by\b`, nil, `xy`, []Group{}},
+	{`\by\b`, nil, `yz`, []Group{}},
+	{`\by\b`, nil, `xyz`, []Group{}},
+	{`x\b`, nil, `xyz`, []Group{}},
+	{`x\B`, nil, `xyz`, []Group{{0, 1}}},
+	{`\Bz`, nil, `xyz`, []Group{{2, 3}}},
+	{`z\B`, nil, `xyz`, []Group{}},
+	{`\Bx`, nil, `xyz`, []Group{}},
+	{`\Ba\B`, nil, `a-`, []Group{}},
+	{`\Ba\B`, nil, `-a`, []Group{}},
+	{`\Ba\B`, nil, `-a-`, []Group{}},
+	{`\By\B`, nil, `xy`, []Group{}},
+	{`\By\B`, nil, `yz`, []Group{}},
+	{`\By\b`, nil, `xy`, []Group{{1, 2}}},
+	{`\by\B`, nil, `yz`, []Group{{0, 1}}},
+	{`\By\B`, nil, `xyz`, []Group{{1, 2}}},
+	{`ab|cd`, nil, `abc`, []Group{{0, 2}}},
+	{`ab|cd`, nil, `abcd`, []Group{{0, 2}, {2, 4}}},
+
+	// Todo - add numeric range tests
+}
+
+var groupTests = []struct {
+	re     string
+	flags  []ReFlag
+	str    string
+	result []Match
+}{
+	{"(a)(b)", nil, "ab", []Match{[]Group{{0, 2}, {0, 1}, {1, 2}}}},
+	{"((a))(b)", nil, "ab", []Match{[]Group{{0, 2}, {0, 1}, {0, 1}, {1, 2}}}},
+	{"(0)", nil, "ab", []Match{[]Group{}}},
+	{"(a)b", nil, "ab", []Match{[]Group{{0, 2}, {0, 1}}}},
+	{"a(b)", nil, "ab", []Match{[]Group{{0, 2}, {1, 2}}}},
+	{"(a|b)", nil, "ab", []Match{[]Group{{0, 1}, {0, 1}}, []Group{{1, 2}, {1, 2}}}},
+	{"(a)|(b)", nil, "ab", []Match{[]Group{{0, 1}, {0, 1}, {-1, -1}}, []Group{{1, 2}, {-1, -1}, {1, 2}}}},
+	{"(a+)(a)", nil, "aaaa", []Match{[]Group{{0, 4}, {0, 3}, {3, 4}}}},
+	{"(a+)|(a)", nil, "aaaa", []Match{[]Group{{0, 4}, {0, 4}, {-1, -1}}}},
+	{"(a+)(aa)", nil, "aaaa", []Match{[]Group{{0, 4}, {0, 2}, {2, 4}}}},
+	{"(aaaa)|(aaaa)", nil, "aaaa", []Match{[]Group{{0, 4}, {0, 4}, {-1, -1}}}},
+	{"(aaa)|(aaaa)", nil, "aaaa", []Match{[]Group{{0, 4}, {-1, -1}, {0, 4}}}},
+	{"(aaa)|(aaaa)", nil, "aaaa", []Match{[]Group{{0, 4}, {-1, -1}, {0, 4}}}},
+	{"(aaaa)|(aaa)", nil, "aaaa", []Match{[]Group{{0, 4}, {0, 4}, {-1, -1}}}},
+	{"(a)|(aa)", nil, "aa", []Match{[]Group{{0, 2}, {-1, -1}, {0, 2}}}},
+	{"(a?)a?", nil, "b", []Match{[]Group{{0, 0}, {0, 0}}, []Group{{1, 1}, {1, 1}}}},
+	{"(a?)a?", nil, "ab", []Match{[]Group{{0, 1}, {0, 1}}, []Group{{1, 1}, {1, 1}}, []Group{{2, 2}, {2, 2}}}},
+	{"(a?)a?", nil, "aa", []Match{[]Group{{0, 2}, {0, 1}}, []Group{{2, 2}, {2, 2}}}},
+	{"a((b.d){3})", nil, "abfdbhdbid", []Match{[]Group{{0, 10}, {1, 10}, {7, 10}}}},
+	{`(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\071`, nil, `abcdefghijkl9`, []Match{[]Group{{0, 13}, {0, 1}, {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8}, {8, 9}, {9, 10}, {10, 11}, {11, 12}}}},
+	{`()ef`, nil, `def`, []Match{[]Group{{1, 3}, {1, 1}}}},
+	{`(?:)ef`, nil, `def`, []Match{[]Group{{1, 3}}}},
+	{`(?:)`, nil, `def`, []Match{[]Group{{0, 0}}, []Group{{1, 1}}, []Group{{2, 2}}, []Group{{3, 3}}}},
+}
+
+func TestFindAllMatches(t *testing.T) {
+	for _, test := range reTests {
+		t.Run(test.re+"	"+test.str, func(t *testing.T) {
+			regComp, err := Compile(test.re, test.flags...)
+			if err != nil {
+				if test.result != nil {
+					panic(fmt.Errorf("Test Error: %v", err))
+				}
+			} else {
+				matchIndices := FindAllMatches(regComp, test.str)
+				zeroGroups := make([]Group, len(matchIndices))
+				for i, m := range matchIndices {
+					zeroGroups[i] = m[0]
+				}
+				if !slices.Equal(test.result, zeroGroups) {
+					t.Errorf("Wanted %v	Got %v\n", test.result, zeroGroups)
+				}
+			}
+		})
+	}
+}
+
+func TestFindString(t *testing.T) {
+	for _, test := range reTests {
+		t.Run(test.re+"	"+test.str, func(t *testing.T) {
+			regComp, err := Compile(test.re, test.flags...)
+			if err != nil {
+				if test.result != nil {
+					panic(err)
+				}
+			} else {
+				foundString := FindString(regComp, test.str)
+				if len(test.result) == 0 {
+					if foundString != "" {
+						t.Errorf("Expected no match got %v\n", foundString)
+					}
+				} else {
+					expectedString := test.str[test.result[0].startIdx:test.result[0].endIdx]
+					if foundString != expectedString {
+						t.Errorf("Wanted %v	Got %v\n", expectedString, foundString)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestFindAllGroups(t *testing.T) {
+	for _, test := range groupTests {
+		t.Run(test.re+"	"+test.str, func(t *testing.T) {
+			regComp, err := Compile(test.re, test.flags...)
+			if err != nil {
+				if test.result != nil {
+					panic(err)
+				}
+			}
+			matchIndices := FindAllMatches(regComp, test.str)
+			for i := range matchIndices {
+				for j := range matchIndices[i] {
+					if matchIndices[i][j].isValid() {
+						if test.result[i][j] != matchIndices[i][j] {
+							t.Errorf("Wanted %v	Got %v\n", test.result, matchIndices)
+						}
+					}
+				}
+			}
+		})
+	}
+}

regex/doc.go

@@ -1,160 +0,0 @@
-/*
-Package regex implements regular expression search, using a custom non-bracktracking engine with support for lookarounds and numeric ranges.
-
-The engine relies completely on UTF-8 codepoints. As such, it is capable of matching characters
-from other languages, emojis and symbols.
-
-The full syntax is specified below.
-
-# Syntax
-
-Single characters:
-
-	.				Match any character. Newline matching is dependent on the RE_SINGLE_LINE flag.
-	[abc]			Character class - match a, b or c
-	[a-z]			Character range - match any character from a to z
-	[^abc]			Negated character class - match any character except a, b and c
-	[^a-z]			Negated character range - do not match any character from a to z
-	\[				Match a literal '['. Backslashes can escape any character with special meaning, including another backslash.
-	\452			Match the character with the octal value 452 (up to 3 digits)
-	\xFF			Match the character with the hex value FF (exactly 2 characters)
-	\x{0000FF}		Match the character with the hex value 0000FF (exactly 6 characters)
-	\n				Newline
-	\a				Bell character
-	\f				Form-feed character
-	\r				Carriage return
-	\t				Horizontal tab
-	\v				Vertical tab
-
-Perl classes:
-
-	\d				Match any digit character ([0-9])
-	\D				Match any non-digit character ([^0-9])
-	\w				Match any word character ([a-zA-Z0-9_])
-	\W				Match any word character ([^a-zA-Z0-9_])
-	\s				Match any whitespace character ([ \t\n])
-	\S				Match any non-whitespace character ([^ \t\n])
-
-POSIX classes (inside normal character classes):
-
-	[:digit:]		All digit characters ([0-9])
-	[:upper:]		All upper-case letters ([A-Z])
-	[:lower:]		All lower-case letters ([a-z])
-	[:alpha:]		All letters ([a-zA-Z])
-	[:alnum:]		All alphanumeric characters ([a-zA-Z0-9])
-	[:xdigit:]		All hexadecimal characters ([a-fA-F0-9])
-	[:blank:]		All blank characters ([ \t])
-	[:space:]		All whitespace characters ([ \t\n\r\f\v])
-	[:cntrl:]		All control characters ([\x00-\x1F\x7F])
-	[:punct:]		All punctuation characters
-	[:graph:]		All graphical characters ([\x21-\x7E])
-	[:print:]		All graphical characters + space ([\x20-\x7E])
-	[:word:]		All word characters (\w)
-	[:ascii:]		All ASCII values ([\x00-\x7F])
-
-Composition:
-
-	def				Match d, followed by e, followed by f
-	x|y				Match x or y (prefer longer one)
-	xy|z			Match xy or z
-
-Repitition (always greedy, preferring more):
-
-	x*				Match x zero or more times
-	x+				Match x one or more times
-	x?				Match x zero or one time
-	x{m,n}			Match x between m and n times (inclusive)
-	x{m,}			Match x atleast m times
-	x{,n}			Match x between 0 and n times (inclusive)
-	x{m}			Match x exactly m times
-
-Grouping:
-
-	(expr)			Create a capturing group. The contents of the group can be retrieved with [FindAllMatches]
-	x(y|z)			Match x followed by y or z. Given a successful match, the contents of group 1 will include either y or z
-	(?:expr)		Create a non-capturing group. The contents of the group aren't saved.
-	x(?:y|z)		Match x followed by y or z. No groups are created.
-
-Assertions:
-
-	^				Match at the start of the input string. If RE_MULTILINE is enabled, it also matches at the start of every line.
-	$				Match at the end of the input string. If RE_MULTILINE is enabled, it also matches at the end of every line.
-	\A				Always match at the start of the string, regardless of RE_MULTILINE
-	\z				Always match at the end of the string, regardless of RE_MULTILINE
-	\b				Match at a word boundary (a word character followed by a non-word character, or vice-versa)
-	\B				Match at a non-word boundary (a word character followed by a word character, or vice-versa)
-
-Lookarounds:
-
-	x(?=y)			Positive lookahead - Match x if followed by y
-	x(?!y)			Negative lookahead - Match x if NOT followed by y
-	(?<=x)y			Positive lookbehind - Match y if preceded by x
-	(?<!x)y			Negative lookbehind - Match y if NOT preceded by x
-
-Numeric ranges:
-
-	<x-y>			Match any number from x to y (inclusive) (x and y must be positive numbers)
-
-# Key Differences with regexp
-
-The engine and the API differ from [regexp] in a number of ways, some of them very subtle.
-The key differences are mentioned below.
-
-1. Greediness:
-
-This engine does not support non-greedy operators. All operators are always greedy in nature, and will try
-to match as much as they can, while still allowing for a successful match. For example, given the regex:
-
-	y*y
-
-The engine will match as many 'y's as it can, while still allowing the trailing 'y' to be matched.
-
-Another, more subtle example is the following regex:
-
-	x|xx
-
-While the stdlib implementation (and most other engines) will prefer matching the first item of the alternation,
-this engine will go for the longest possible match, regardless of the order of the alternation. Although this
-strays from the convention, it results in a nice rule-of-thumb - the engine is ALWAYS greedy.
-
-The stdlib implementation has a function [regexp.Regexp.Longest] which makes future searches prefer the longest match.
-That is the default (and unchangable) behavior in this engine.
-
-2. Byte-slices and runes:
-
-My engine does not support byte-slices. When a matching function receives a string, it converts it into a
-rune-slice to iterate through it. While this has some space overhead, the convenience of built-in unicode
-support made the tradeoff worth it.
-
-3. Return values
-
-Rather than using primitives for return values, my engine defines two types that are used as return
-values: a [Group] represents a capturing group, and a [Match] represents a list of groups.
-
-[regexp] specifies a regular expression that gives a list of all the matching functions that it supports. The
-equivalent expression for this engine is:
-
-	Find(All)?(String)?(Submatch)?
-
-[Reg.Find] returns the index of the leftmost match in the string.
-
-If a function contains 'All' it returns all matches instead of just the leftmost one.
-
-If a function contains 'String' it returns the matched text, rather than the indices.
-
-If a function contains 'Submatch' it returns the match, including all submatches found by
-capturing groups.
-
-The term '0-group' is used to refer to the 0th capturing group of a match (which is the entire match).
-Given the following regex:
-
-	x(y)
-
-and the input string:
-
-	xyz
-
-The 0th group would contain 'xy' and the 1st group would contain 'y'. Any matching function without 'Submatch' in its name
-returns the 0-group.
-*/
-package regex

regex/example_test.go

@@ -1,54 +0,0 @@
-package regex_test
-
-import (
-	"fmt"
-
-	"gitea.twomorecents.org/Rockingcool/kleingrep/regex"
-)
-
-func ExampleReg_Find() {
-	regexStr := "b|a"
-	regexComp := regex.MustCompile(regexStr)
-
-	match, _ := regexComp.Find("banana")
-	fmt.Println(match.String())
-
-	// Output: 0	1
-}
-
-func ExampleReg_FindAll() {
-	regexStr := "b|a"
-	regexComp := regex.MustCompile(regexStr)
-
-	matches := regexComp.FindAll("banana")
-	for _, group := range matches {
-		fmt.Println(group.String())
-	}
-
-	// Output: 0	1
-	// 1	2
-	// 3	4
-	// 5	6
-}
-
-func ExampleReg_FindString() {
-	regexStr := `\d+`
-	regexComp := regex.MustCompile(regexStr)
-
-	matchStr := regexComp.FindString("The year of our lord, 2025")
-	fmt.Println(matchStr)
-	// Output: 2025
-}
-
-func ExampleReg_FindSubmatch() {
-	regexStr := `(\d)\.(\d)(\d)`
-	regexComp := regex.MustCompile(regexStr)
-
-	match, _ := regexComp.FindSubmatch("3.14")
-	fmt.Println(match[0])
-	fmt.Println(match[1])
-	fmt.Println(match[2])
-	// Output: 0	4
-	// 0	1
-	// 2	3
-}

regex/nfa.go

@@ -1,380 +0,0 @@
-package regex
-
-import (
-	"fmt"
-	"slices"
-)
-
-const epsilon int = 0xF0000
-
-type assertType int
-
-const (
-	noneAssert assertType = iota
-	sosAssert             // Start of string (^)
-	soiAssert             // Start of input (\A)
-	eosAssert             // End of string ($)
-	eoiAssert             // End of input (\Z)
-	wboundAssert
-	nonwboundAssert
-	plaAssert        // Positive lookahead
-	nlaAssert        // Negative lookahead
-	plbAssert        // Positive lookbehind
-	nlbAssert        // Negative lookbehind
-	alwaysTrueAssert // An assertion that is always true
-)
-
-type nfaState 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                     []*nfaState         // The outputs of the current state ie. the 'outward arrows'. A union operator state will have more than one of these.
-	transitions                map[int][]*nfaState // 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              *nfaState           // 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
-	groupNum                   int                 // Which capturing group the node starts / ends
-	// The following properties depend on the current match - I should think about resetting them for every match.
-	zeroMatchFound bool    // Whether or not the state has been used for a zero-length match - only relevant for zero states
-	threadGroups   []Group // Assuming that a state is part of a 'thread' in the matching process, this array stores the indices of capturing groups in the current thread. As matches are found for this state, its groups will be copied over.
-}
-
-// Clones the NFA starting from the given state.
-func cloneState(start *nfaState) *nfaState {
-	return cloneStateHelper(start, make(map[*nfaState]*nfaState))
-}
-
-// 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 *nfaState, cloneMap map[*nfaState]*nfaState) *nfaState {
-	// Base case - if the clone exists in our map, return it.
-	if clone, exists := cloneMap[stateToClone]; exists {
-		return clone
-	}
-	if stateToClone == nil {
-		return nil
-	}
-	// 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 := &nfaState{
-		content:         append([]int{}, stateToClone.content...),
-		isEmpty:         stateToClone.isEmpty,
-		isLast:          stateToClone.isLast,
-		output:          make([]*nfaState, len(stateToClone.output)),
-		transitions:     make(map[int][]*nfaState),
-		isKleene:        stateToClone.isKleene,
-		assert:          stateToClone.assert,
-		zeroMatchFound:  stateToClone.zeroMatchFound,
-		allChars:        stateToClone.allChars,
-		except:          append([]rune{}, stateToClone.except...),
-		lookaroundRegex: stateToClone.lookaroundRegex,
-		groupEnd:        stateToClone.groupEnd,
-		groupBegin:      stateToClone.groupBegin,
-		groupNum:        stateToClone.groupNum,
-	}
-	cloneMap[stateToClone] = clone
-	for i, s := range stateToClone.output {
-		if s == stateToClone {
-			clone.output[i] = clone
-		} else {
-			clone.output[i] = cloneStateHelper(s, cloneMap)
-		}
-	}
-	for k, v := range stateToClone.transitions {
-		clone.transitions[k] = make([]*nfaState, len(v))
-		for i, s := range v {
-			if s == stateToClone {
-				clone.transitions[k][i] = clone
-			} else {
-				clone.transitions[k][i] = cloneStateHelper(s, cloneMap)
-			}
-		}
-	}
-	if stateToClone.lookaroundNFA == stateToClone {
-		clone.lookaroundNFA = clone
-	}
-	clone.lookaroundNFA = cloneStateHelper(stateToClone.lookaroundNFA, cloneMap)
-	return clone
-}
-
-// Reset any thread-related fields of the NFA starting from the given state.
-func resetThreads(start *nfaState) {
-	visitedMap := make(map[*nfaState]bool) // The value type doesn't matter here
-	resetThreadsHelper(start, visitedMap)
-}
-
-func resetThreadsHelper(state *nfaState, visitedMap map[*nfaState]bool) {
-	if _, ok := visitedMap[state]; ok {
-		return
-	}
-	// Assuming it hasn't been visited
-	state.threadGroups = nil
-	visitedMap[state] = true
-	for _, v := range state.transitions {
-		for _, nextState := range v {
-			resetThreadsHelper(nextState, visitedMap)
-		}
-	}
-}
-
-// Checks if the given state's assertion is true. Returns true if the given
-// state doesn't have an assertion.
-func (s nfaState) checkAssertion(str []rune, idx int) bool {
-	if s.assert == alwaysTrueAssert {
-		return true
-	}
-	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 == 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 == soiAssert {
-		// Only true at the start of the input, regardless of mode
-		return idx == 0
-	}
-	if s.assert == eoiAssert {
-		// Only true at the end of the input, regardless of mode
-		return idx == len(str)
-	}
-
-	if s.assert == wboundAssert {
-		return isWordBoundary(str, idx)
-	}
-	if s.assert == nonwboundAssert {
-		return !isWordBoundary(str, idx)
-	}
-	if s.isLookaround() {
-		// The process here is simple:
-		// 		1. Compile the regex stored in the state's contents.
-		// 		2. Run it on a subset of the test string, that ends after the current index in the string
-		// 		3. Based on the kind of lookaround (and the indices we get), determine what action to take.
-		startState := s.lookaroundNFA
-		var runesToMatch []rune
-		var strToMatch string
-		if s.assert == plaAssert || s.assert == nlaAssert {
-			runesToMatch = str[idx:]
-		} else {
-			runesToMatch = str[:idx]
-		}
-
-		if len(runesToMatch) == 0 {
-			strToMatch = ""
-		} else {
-			strToMatch = string(runesToMatch)
-		}
-
-		regComp := Reg{startState, s.lookaroundNumCaptureGroups}
-		matchIndices := regComp.FindAll(strToMatch)
-
-		numMatchesFound := 0
-		for _, matchIdx := range matchIndices {
-			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.StartIdx == 0 {
-					numMatchesFound++
-				}
-			}
-			if s.assert == plbAssert || s.assert == nlbAssert { // Lookbehind - return true (or false) if at least one match _ends_ at the current index.
-				if matchIdx.EndIdx == idx {
-					numMatchesFound++
-				}
-			}
-		}
-		if s.assert == plaAssert || s.assert == plbAssert { // Positive assertions want at least one match
-			return numMatchesFound > 0
-		}
-		if s.assert == nlaAssert || s.assert == nlbAssert { // Negative assertions only want zero matches
-			return numMatchesFound == 0
-		}
-	}
-	return true
-}
-
-// Returns true if the contents of 's' contain the value at the given index of the given string
-func (s nfaState) contentContains(str []rune, idx int) bool {
-	if s.assert != noneAssert {
-		return s.checkAssertion(str, idx)
-	}
-	if s.allChars {
-		return !slices.Contains(slices.Concat(notDotChars, s.except), str[idx]) // Return true only if the index isn't a 'notDotChar', or isn't one of the exception characters for the current node.
-	}
-	// Default - s.assert must be NONE
-	return slices.Contains(s.content, int(str[idx]))
-}
-
-func (s nfaState) 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 nfaState) matchesFor(str []rune, idx int) ([]*nfaState, 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([]*nfaState, 0), -1
-		}
-	}
-	listTransitions := s.transitions[int(str[idx])]
-	for _, dest := range s.transitions[int(anyCharRune)] {
-		if !slices.Contains(slices.Concat(notDotChars, dest.except), str[idx]) {
-			// Add an allChar state to the list of matches if:
-			// 		a. The current character isn't a 'notDotChars' character. In single line mode, this includes newline. In multiline mode, it doesn't.
-			// 		b. The current character isn't the state's exception list.
-			listTransitions = append(listTransitions, dest)
-		}
-	}
-	numTransitions := len(listTransitions)
-	return listTransitions, numTransitions
-}
-
-// verifyLastStatesHelper performs the depth-first recursion needed for verifyLastStates
-func verifyLastStatesHelper(st *nfaState, visited map[*nfaState]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(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 st.content {
-			if len(st.transitions[c]) != 1 || st.transitions[c][0] != st {
-				moreThanOneTrans = true
-			}
-		}
-		st.isLast = !moreThanOneTrans
-	}
-
-	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([]*nfaState, 0)
-		for _, v := range st.transitions {
-			transitionDests = append(transitionDests, v...)
-		}
-		if allEqual(transitionDests...) {
-			st.isLast = true
-			return
-		}
-	}
-	if visited[st] == true {
-		return
-	}
-	visited[st] = true
-	for _, states := range st.transitions {
-		for i := range states {
-			if states[i] != st {
-				verifyLastStatesHelper(states[i], visited)
-			}
-		}
-	}
-}
-
-// verifyLastStates enables the 'isLast' flag for the leaf nodes (last states)
-func verifyLastStates(start []*nfaState) {
-	verifyLastStatesHelper(start[0], make(map[*nfaState]bool))
-}
-
-// Concatenates s1 and s2, returns the start of the concatenation.
-func concatenate(s1 *nfaState, s2 *nfaState) *nfaState {
-	if s1 == nil {
-		return s2
-	}
-	for i := range s1.output {
-		for _, c := range s2.content { // Create transitions for every element in s1's content to s2'
-			s1.output[i].transitions[c], _ = uniqueAppend(s1.output[i].transitions[c], s2)
-		}
-	}
-	s1.output = s2.output
-	return s1
-}
-
-func kleene(s1 nfaState) (*nfaState, error) {
-	if s1.isEmpty && s1.assert != noneAssert {
-		return nil, fmt.Errorf("previous token is not quantifiable")
-	}
-
-	toReturn := &nfaState{}
-	toReturn.transitions = make(map[int][]*nfaState)
-	toReturn.content = newContents(epsilon)
-	toReturn.isEmpty = true
-	toReturn.isKleene = true
-	toReturn.output = append(toReturn.output, toReturn)
-	for i := range s1.output {
-		for _, c := range toReturn.content {
-			s1.output[i].transitions[c], _ = uniqueAppend(s1.output[i].transitions[c], toReturn)
-		}
-	}
-	for _, c := range s1.content {
-		toReturn.transitions[c], _ = uniqueAppend(toReturn.transitions[c], &s1)
-	}
-	return toReturn, nil
-}
-
-func alternate(s1 *nfaState, s2 *nfaState) *nfaState {
-	toReturn := &nfaState{}
-	toReturn.transitions = make(map[int][]*nfaState)
-	toReturn.output = append(toReturn.output, s1.output...)
-	toReturn.output = append(toReturn.output, s2.output...)
-	// Unique append is used here (and elsewhere) to ensure that,
-	// for any given transition, a state can only be mentioned once.
-	// For example, given the transition 'a', the state 's1' can only be mentioned once.
-	// This would lead to multiple instances of the same set of match indices, since both
-	// 's1' states would be considered to match.
-	for _, c := range s1.content {
-		toReturn.transitions[c], _ = uniqueAppend(toReturn.transitions[c], s1)
-	}
-	for _, c := range s2.content {
-		toReturn.transitions[c], _ = uniqueAppend(toReturn.transitions[c], s2)
-	}
-	toReturn.content = newContents(epsilon)
-	toReturn.isEmpty = true
-
-	return toReturn
-}
-
-func question(s1 *nfaState) *nfaState { // Use the fact that ab? == a(b|)
-	s2 := &nfaState{}
-	s2.transitions = make(map[int][]*nfaState)
-	s2.content = newContents(epsilon)
-	s2.output = append(s2.output, s2)
-	s2.isEmpty = true
-	s3 := alternate(s1, s2)
-	return s3
-}
-
-// Creates and returns a new state with the 'default' values.
-func newState() nfaState {
-	ret := nfaState{
-		output:          make([]*nfaState, 0),
-		transitions:     make(map[int][]*nfaState),
-		assert:          noneAssert,
-		except:          append([]rune{}, 0),
-		lookaroundRegex: "",
-		groupEnd:        false,
-		groupBegin:      false,
-	}
-	ret.output = append(ret.output, &ret)
-	return ret
-}
-
-// Creates and returns a state that _always_ has a zero-length match.
-func zeroLengthMatchState() nfaState {
-	start := newState()
-	start.content = newContents(epsilon)
-	start.isEmpty = true
-	start.assert = alwaysTrueAssert
-	return start
-}

regex/noteOnPCREBackreferences.txt

@@ -1,7 +0,0 @@
-In PCRE, following a backreference by _any_ number seems to turn it into an octal value. Why is this?
-
-Eg.
-`(a)\1` <-- Backreference
-`(a)\17` <-- Octal '17'
-`(a)\19` <-- Octal 1, then literal 9
-`(a)\1a` <-- Backreference, then 'a'

regex/re_test.go

@@ -1,825 +0,0 @@
-package regex
-
-import (
-	"fmt"
-	"slices"
-	"testing"
-)
-
-var reTests = []struct {
-	re     string
-	flags  []ReFlag
-	str    string
-	result []Group // Stores all zero-groups in the match
-}{
-	{"a", nil, "abc", []Group{{0, 1}}},
-	{"a", nil, "bca", []Group{{2, 3}}},
-	{"l", nil, "ggllgg", []Group{{2, 3}, {3, 4}}},
-	{"(b|c)", nil, "abdceb", []Group{{1, 2}, {3, 4}, {5, 6}}},
-	{"a+", nil, "brerereraaaaabbbbb", []Group{{8, 13}}},
-	{"ab+", nil, "qweqweqweaqweqweabbbbbr", []Group{{16, 22}}},
-	{"(b|c|A)", nil, "ooaoobocA", []Group{{5, 6}, {7, 8}, {8, 9}}},
-	{"ab*", nil, "a", []Group{{0, 1}}},
-	{"ab*", nil, "abb", []Group{{0, 3}}},
-	{"a*b", nil, "aaab", []Group{{0, 4}}},
-	{"a*b", nil, "qwqw", []Group{}},
-	{"(abc)*", nil, "abcabcabc", []Group{{0, 9}, {9, 9}}},
-	{"((abc)|(def))*", nil, "abcdef", []Group{{0, 6}, {6, 6}}},
-	{"(abc)*|(def)*", nil, "abcdef", []Group{{0, 3}, {3, 6}, {6, 6}}},
-	{"b*a*a", nil, "bba", []Group{{0, 3}}},
-	{"(ab)+", nil, "abcabddd", []Group{{0, 2}, {3, 5}}},
-	{"a(b(c|d)*)*", nil, "abccbd", []Group{{0, 6}}},
-	{"a(b|c)*d+", nil, "abccdd", []Group{{0, 6}}},
-	{"a*", nil, "", []Group{{0, 0}}},
-	{"a|b", nil, "c", []Group{}},
-	{"(a|b)*c", nil, "aabbc", []Group{{0, 5}}},
-	{"a(b|b)", nil, "ab", []Group{{0, 2}}},
-	{"a*", nil, "aaaaaaaa", []Group{{0, 8}, {8, 8}}},
-
-	{"ab?", nil, "ab", []Group{{0, 2}}},
-	{"a?b", nil, "ab", []Group{{0, 2}}},
-	{"a?", nil, "", []Group{{0, 0}}},
-	{"a?b?c", nil, "a", []Group{}},
-	{"a?b?c?", nil, "ab", []Group{{0, 2}, {2, 2}}},
-	{"a?b?c?", nil, "ac", []Group{{0, 2}, {2, 2}}},
-	{"a?b?c", nil, "abc", []Group{{0, 3}}},
-	{"a?b?c", nil, "acb", []Group{{0, 2}}},
-
-	{"[abc]", nil, "defadefbdefce", []Group{{3, 4}, {7, 8}, {11, 12}}},
-	{"[ab]c", nil, "ab", []Group{}},
-	{"g[ab]c", nil, "gac", []Group{{0, 3}}},
-	{"g[ab]c", nil, "gbc", []Group{{0, 3}}},
-	{"g[ab]c", nil, "gc", []Group{}},
-	{"g[ab]c", nil, "gfc", []Group{}},
-	{"[ab]*", nil, "aabbbabaababab", []Group{{0, 14}, {14, 14}}},
-	{"[ab]+", nil, "aabbbablaababab", []Group{{0, 7}, {8, 15}}},
-	{"[Ff]r[Uu]it", nil, "fruit", []Group{{0, 5}}},
-	{"[Ff]r[Uu]it", nil, "FrUit", []Group{{0, 5}}},
-	{"[Ff]r[Uu|]it", nil, "Fr|it", []Group{{0, 5}}},
-	{"[Ff]r([Uu]|[pP])it", nil, "Frpit", []Group{{0, 5}}},
-	{"[Ff]r[Uu]|[pP]it", nil, "Frpit", []Group{{2, 5}}},
-	{"[a-zA-Z]+", nil, "Hello, how is it going?", []Group{{0, 5}, {7, 10}, {11, 13}, {14, 16}, {17, 22}}},
-
-	{".+", nil, "Hello, how is it going?", []Group{{0, 23}}},
-	{"a.", nil, "a ", []Group{{0, 2}}},
-	{"a.b", nil, "a/b", []Group{{0, 3}}},
-	{".", nil, "a ", []Group{{0, 1}, {1, 2}}},
-	{"a.", nil, "a ", []Group{{0, 2}}},
-	{".+b", nil, "abc", []Group{{0, 2}}},
-
-	{`\d`, nil, "1a0a3s'''34343s", []Group{{0, 1}, {2, 3}, {4, 5}, {9, 10}, {10, 11}, {11, 12}, {12, 13}, {13, 14}}},
-	{`\\`, nil, `a\b\c\qwe\`, []Group{{1, 2}, {3, 4}, {5, 6}, {9, 10}}},
-	{`\W`, nil, `"Hello", he said. How are you doing?`, []Group{{0, 1}, {6, 7}, {7, 8}, {8, 9}, {11, 12}, {16, 17}, {17, 18}, {21, 22}, {25, 26}, {29, 30}, {35, 36}}},
-	{`\w`, nil, ";';';';';'qwe12", []Group{{10, 11}, {11, 12}, {12, 13}, {13, 14}, {14, 15}}},
-	{`\s`, nil, "a b c 	d", []Group{{1, 2}, {3, 4}, {5, 6}, {6, 7}}},
-	{`\<`, nil, "<HTML><body>", []Group{{0, 1}, {6, 7}}},
-	{`\(.+\)`, nil, "Not (paranthesized), (so) is (this) not", []Group{{4, 35}}},
-
-	{"[^abc]+", nil, "qarbtopsaplpclkpasdmb prejip0r,p", []Group{{0, 1}, {2, 3}, {4, 8}, {9, 12}, {13, 16}, {17, 20}, {21, 32}}},
-	{"[^a]+", nil, "qqqaq", []Group{{0, 3}, {4, 5}}},
-	{"[^0-9]+", nil, "a1b2c3dd", []Group{{0, 1}, {2, 3}, {4, 5}, {6, 8}}},
-	{"[^abc]+", nil, "ababababbababaccacacacaca", []Group{}},
-	{`\[`, nil, "a[b[c[]]]", []Group{{1, 2}, {3, 4}, {5, 6}}},
-	{`\([^)]+\)`, nil, "Not (paranthesized), (so) is (this) not", []Group{{4, 19}, {21, 25}, {29, 35}}},
-
-	{"^ab", nil, "ab bab", []Group{{0, 2}}},
-	{"^aaaa^", nil, "aaaaaaaa", []Group{}},
-	{"^([bB][Gg])", nil, "bG", []Group{{0, 2}}},
-	{"b$", nil, "ba", []Group{}},
-	{"(boy|girl)$", nil, "girlf", []Group{}},
-	{`\bint\b`, nil, "print int integer", []Group{{6, 9}}},
-	{`int\b`, nil, "ints", []Group{}},
-	{`int(\b|a)`, nil, "inta", []Group{{0, 4}}},
-	{`\b\d+\b`, nil, "511 a3 43", []Group{{0, 3}, {7, 9}}},
-	{`\Bint\B`, nil, "prints int integer print", []Group{{2, 5}}},
-	{`^`, nil, "5^3^2", []Group{{0, 0}}},
-	{`\^`, nil, "5^3^2", []Group{{1, 2}, {3, 4}}},
-	{`pool$`, nil, "pool carpool", []Group{{8, 12}}},
-	{`^int$`, nil, "print int integer", []Group{}},
-	{`^int$`, nil, "int", []Group{{0, 3}}},
-	{`b*`, nil, "aaaaaaaaaaqweqwe", []Group{{0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}, {9, 9}, {10, 10}, {11, 11}, {12, 12}, {13, 13}, {14, 14}, {15, 15}, {16, 16}}},
-
-	{"a{4}", nil, "aabaaa", []Group{}},
-	{"ab{5}", nil, "abbbbbab", []Group{{0, 6}}},
-	{"(a|b){3,4}", nil, "aba", []Group{{0, 3}}},
-	{"(a|b){3,4}", nil, "ababaa", []Group{{0, 4}}},
-	{"(bc){5,}", nil, "bcbcbcbcbcbcbcbc", []Group{{0, 16}}},
-	{`\d{3,4}`, nil, "1209", []Group{{0, 4}}},
-	{`\d{3,4}`, nil, "120", []Group{{0, 3}}},
-	{`\d{3,4}`, nil, "12709", []Group{{0, 4}}},
-	{`\d{3,4}`, nil, "12", []Group{}},
-	{`\d{3,4}`, nil, "109", []Group{{0, 3}}},
-	{`\d{3,4}`, nil, "5", []Group{}},
-	{`\d{3,4}`, nil, "123135", []Group{{0, 4}}},
-	{`\d{3,4}`, nil, "89a-0", []Group{}},
-	{`\d{3,4}`, nil, "ababab555", []Group{{6, 9}}},
-	{`\bpaint\b`, nil, "paints", []Group{}},
-	{`\b\w{5}\b`, nil, "paint", []Group{{0, 5}}},
-	{`[^\w]`, nil, "abcdef1230[]qq';;'", []Group{{10, 11}, {11, 12}, {14, 15}, {15, 16}, {16, 17}, {17, 18}}},
-	{`[^\W]`, nil, "abcdef1230[]qq';;'", []Group{{0, 1}, {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8}, {8, 9}, {9, 10}, {12, 13}, {13, 14}}},
-	{`[\[\]]`, nil, "a[b[l]]", []Group{{1, 2}, {3, 4}, {5, 6}, {6, 7}}},
-
-	// Unicode tests
-	{`.+`, nil, "úïäö´«åæïëòöê»éãçâï«úïòíñ", []Group{{0, 25}}},
-	{`a.b`, nil, "a²b", []Group{{0, 3}}},
-	{`[^a]+`, nil, "úïäö´«åæïëòöê»éãçâï«úïòíñ", []Group{{0, 25}}},
-
-	// Fun experiment - AI-generated tests
-	{"(abc|def|ghi)", nil, "abcdefg", []Group{{0, 3}, {3, 6}}},
-	{"a(b|c)d", nil, "abcd", []Group{}},
-	{"a(b|c)*d", nil, "abcbcd", []Group{{0, 6}}},
-	{"a(b|c)+d", nil, "abcbcd", []Group{{0, 6}}},
-	{"a(b|c)?d", nil, "abd", []Group{{0, 3}}},
-	{".+", nil, "hello world", []Group{{0, 11}}},
-	{"a.b", nil, "aXb", []Group{{0, 3}}},
-	{"a.*b", nil, "aXb", []Group{{0, 3}}},
-	{"a.{2,3}b", nil, "aXXb", []Group{{0, 4}}},
-	{"a.{2,}b", nil, "aXXXb", []Group{{0, 5}}},
-	{"a.{0,3}b", nil, "ab", []Group{{0, 2}}},
-	{"[abc]+", nil, "abcabc", []Group{{0, 6}}},
-	{"[a-zA-Z]+", nil, "HelloWorld", []Group{{0, 10}}},
-	{"[^abc]+", nil, "defghi", []Group{{0, 6}}},
-	{"^hello", nil, "hello world", []Group{{0, 5}}},
-	{"world$", nil, "hello world", []Group{{6, 11}}},
-	{`\bhello\b`, nil, "hello world", []Group{{0, 5}}},
-	{`\Bhello\B`, nil, "hello world", []Group{}},
-	{"(hello|world)", nil, "hello world", []Group{{0, 5}, {6, 11}}},
-	{"(hello|world)+", nil, "hello world", []Group{{0, 5}, {6, 11}}},
-	{"(hello|world)*", nil, "hello world", []Group{{0, 5}, {5, 5}, {6, 11}, {11, 11}}},
-	{"(hello|world)?", nil, "hello world", []Group{{0, 5}, {5, 5}, {6, 11}, {11, 11}}},
-	{"ú.+ï", nil, "úïäö´«åæïëòöê»éãçâï«úïòíñ", []Group{{0, 22}}},
-	{"(?=hello)", nil, "hello world", []Group{{0, 0}}},
-	{"(?!hello)", nil, "hello world", []Group{{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}, {7, 7}, {8, 8}, {9, 9}, {10, 10}, {11, 11}}},
-	{"(?<=hello)", nil, "hello world", []Group{{5, 5}}},
-	{"(?<!hello)", nil, "hello world", []Group{{0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {6, 6}, {7, 7}, {8, 8}, {9, 9}, {10, 10}, {11, 11}}},
-	{"^((3[7-9])|([4-9][0-9])|([1-9][0-9][0-9])|(1000))$", nil, "40", []Group{{0, 2}}},
-	{"^((3[7-9])|([4-9][0-9])|([1-9][0-9][0-9])|(1000))$", nil, "040", []Group{}},
-	{"^((3[7-9])|([4-9][0-9])|([1-9][0-9][0-9])|(1000))$", nil, "400", []Group{{0, 3}}},
-	{"^((3[7-9])|([4-9][0-9])|([1-9][0-9][0-9])|(1000))$", nil, "4000", []Group{}},
-	{"a{1,3}", nil, "aaaaa", []Group{{0, 3}, {3, 5}}},
-	{`\\[ab\\]`, nil, "a", []Group{}},
-	{`\\[ab\\]`, nil, `\a`, []Group{{0, 2}}},
-
-	// Lookaround tests
-	{"(?<=bo)y", nil, "boy", []Group{{2, 3}}},
-	{"bo(?=y)", nil, "boy", []Group{{0, 2}}},
-	{"(?<=f)f+(?=f)", nil, "fffff", []Group{{1, 4}}},
-	{"(?<=f)f+(?=f)", nil, "fffffa", []Group{{1, 4}}},
-
-	// Some POSIX charclass tests
-	{"[[:lower:]]+", nil, "abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789!@#$%^&*", []Group{{0, 26}}},
-	{"[[:upper:]]+", nil, "abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789!@#$%^&*", []Group{{26, 52}}},
-	{"[[:alpha:]]+", nil, "abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789!@#$%^&*", []Group{{0, 52}}},
-	{"[[:digit:]]+", nil, "abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789!@#$%^&*", []Group{{52, 62}}},
-	{"[[:alnum:]]+", nil, "abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789!@#$%^&*", []Group{{0, 62}}},
-	{"[[:punct:]]+", nil, "abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789!@#$%^&*", []Group{{62, 70}}},
-	{"[[:ascii:]]+", nil, "abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789!@#$%^&*", []Group{{0, 70}}},
-	{"[[:graph:]]+", nil, "abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789!@#$%^&*", []Group{{0, 70}}},
-
-	// Test cases from Python's RE test suite
-	{`[\1]`, nil, "\x01", []Group{{0, 1}}},
-
-	{`\0`, nil, "\x00", []Group{{0, 1}}},
-	{`[\0a]`, nil, "\x00", []Group{{0, 1}}},
-	{`[\0a]`, nil, "\x00", []Group{{0, 1}}},
-	{`[a\0]`, nil, "\x00", []Group{{0, 1}}},
-	{`[^a\0]`, nil, "\x00", []Group{}},
-
-	{`\a[\b]\f\n\r\t\v`, nil, "\a\b\f\n\r\t\v", []Group{{0, 7}}},
-	{`[\a][\b][\f][\n][\r][\t][\v]`, nil, "\a\b\f\n\r\t\v", []Group{{0, 7}}},
-	{`\u`, nil, "", nil},
-	{`\xff`, nil, "ÿ", []Group{{0, 1}}},
-	{`\x00ffffffffffffff`, nil, "\xff", []Group{}},
-	{`\x00f`, nil, "\x0f", []Group{}},
-	{`\x00fe`, nil, "\xfe", []Group{}},
-	{`^\w+=(\\[\000-\277]|[^\n\\])*`, nil, "SRC=eval.c g.c blah blah blah \\\\\n\tapes.c", []Group{{0, 32}}},
-
-	{`a.b`, nil, `acb`, []Group{{0, 3}}},
-	{`a.b`, nil, "a\nb", []Group{}},
-	{`a.*b`, nil, "acc\nccb", []Group{}},
-	{`a.{4,5}b`, nil, "acc\nccb", []Group{}},
-	{`a.b`, nil, "a\rb", []Group{{0, 3}}},
-	{`a.b`, []ReFlag{RE_SINGLE_LINE}, "a\nb", []Group{{0, 3}}},
-	{`a.*b`, []ReFlag{RE_SINGLE_LINE}, "acc\nccb", []Group{{0, 7}}},
-	{`a.{4,5}b`, []ReFlag{RE_SINGLE_LINE}, "acc\nccb", []Group{{0, 7}}},
-
-	{`)`, nil, ``, nil},
-	{`^$`, nil, ``, []Group{{0, 0}}},
-	{`abc`, nil, `abc`, []Group{{0, 3}}},
-	{`abc`, nil, `xbc`, []Group{}},
-	{`abc`, nil, `axc`, []Group{}},
-	{`abc`, nil, `abx`, []Group{}},
-	{`abc`, nil, `xabcy`, []Group{{1, 4}}},
-	{`abc`, nil, `ababc`, []Group{{2, 5}}},
-	{`ab*c`, nil, `abc`, []Group{{0, 3}}},
-	{`ab*bc`, nil, `abc`, []Group{{0, 3}}},
-	{`ab*bc`, nil, `abbc`, []Group{{0, 4}}},
-	{`ab*bc`, nil, `abbbbc`, []Group{{0, 6}}},
-	{`ab{0,}c`, nil, `abbbbc`, []Group{{0, 6}}},
-	{`ab+bc`, nil, `abbc`, []Group{{0, 4}}},
-	{`ab+bc`, nil, `abc`, []Group{}},
-	{`ab+bc`, nil, `abq`, []Group{}},
-	{`ab{1,}bc`, nil, `abq`, []Group{}},
-	{`ab+bc`, nil, `abbbbc`, []Group{{0, 6}}},
-	{`ab{1,}bc`, nil, `abbbbc`, []Group{{0, 6}}},
-	{`ab{1,3}bc`, nil, `abbbbc`, []Group{{0, 6}}},
-	{`ab{3,4}bc`, nil, `abbbbc`, []Group{{0, 6}}},
-	{`ab{4,5}bc`, nil, `abbbbc`, []Group{}},
-	{`ab?bc`, nil, `abbc`, []Group{{0, 4}}},
-	{`ab?bc`, nil, `abc`, []Group{{0, 3}}},
-	{`ab{0,1}bc`, nil, `abc`, []Group{{0, 3}}},
-	{`ab?bc`, nil, `abbbbc`, []Group{}},
-	{`ab?c`, nil, `abc`, []Group{{0, 3}}},
-	{`^abc$`, nil, `abc`, []Group{{0, 3}}},
-	{`^abc$`, nil, `abcc`, []Group{}},
-	{`^abc`, nil, `abcc`, []Group{{0, 3}}},
-	{`^abc$`, nil, `aabc`, []Group{}},
-	{`abc$`, nil, `aabc`, []Group{{1, 4}}},
-	{`^`, nil, `abc`, []Group{{0, 0}}},
-	{`$`, nil, `abc`, []Group{{3, 3}}},
-	{`a.c`, nil, `abc`, []Group{{0, 3}}},
-	{`a.c`, nil, `axc`, []Group{{0, 3}}},
-	{`a.*c`, nil, `axyzc`, []Group{{0, 5}}},
-	{`a.*c`, nil, `axyzd`, []Group{}},
-	{`a[bc]d`, nil, `abc`, []Group{}},
-	{`a[bc]d`, nil, `abd`, []Group{{0, 3}}},
-	{`a[b-d]e`, nil, `abd`, []Group{}},
-	{`a[b-d]e`, nil, `ace`, []Group{{0, 3}}},
-	{`a[b-d]`, nil, `aac`, []Group{{1, 3}}},
-	{`a[-b]`, nil, `a-`, []Group{{0, 2}}}, // If a character class has a hyphen without a start or end character, it is treated as a literal hyphen
-	{`a[\-b]`, nil, `a-`, []Group{{0, 2}}},
-	{`a[b-]`, nil, `a-`, []Group{{0, 2}}}, // If a character class has a hyphen without a start or end character, it is treated as a literal hyphen
-
-	{`a[]b`, nil, `-`, nil},
-	{`a[`, nil, `-`, nil},
-	{`a\`, nil, `-`, nil},
-	{`abc)`, nil, `-`, nil},
-	{`(abc`, nil, `-`, nil},
-	{`a]`, nil, `a]`, []Group{{0, 2}}},
-	{`a[]]b`, nil, `a]b`, []Group{{0, 3}}},
-	{`a[\]]b`, nil, `a]b`, []Group{{0, 3}}},
-	{`a[^bc]d`, nil, `aed`, []Group{{0, 3}}},
-	{`a[^bc]d`, nil, `abd`, []Group{}},
-	{`a[^-b]c`, nil, `adc`, []Group{{0, 3}}},
-	{`a[^-b]c`, nil, `a-c`, []Group{}},
-	{`a[^]b]c`, nil, `a]c`, []Group{}},
-	{`a[^]b]c`, nil, `adc`, []Group{{0, 3}}},
-	{`\ba\b`, nil, `a-`, []Group{{0, 1}}},
-	{`\ba\b`, nil, `-a`, []Group{{1, 2}}},
-	{`\ba\b`, nil, `-a-`, []Group{{1, 2}}},
-	{`\by\b`, nil, `xy`, []Group{}},
-	{`\by\b`, nil, `yz`, []Group{}},
-	{`\by\b`, nil, `xyz`, []Group{}},
-	{`x\b`, nil, `xyz`, []Group{}},
-	{`x\B`, nil, `xyz`, []Group{{0, 1}}},
-	{`\Bz`, nil, `xyz`, []Group{{2, 3}}},
-	{`z\B`, nil, `xyz`, []Group{}},
-	{`\Bx`, nil, `xyz`, []Group{}},
-	{`\Ba\B`, nil, `a-`, []Group{}},
-	{`\Ba\B`, nil, `-a`, []Group{}},
-	{`\Ba\B`, nil, `-a-`, []Group{}},
-	{`\By\B`, nil, `xy`, []Group{}},
-	{`\By\B`, nil, `yz`, []Group{}},
-	{`\By\b`, nil, `xy`, []Group{{1, 2}}},
-	{`\by\B`, nil, `yz`, []Group{{0, 1}}},
-	{`\By\B`, nil, `xyz`, []Group{{1, 2}}},
-	{`ab|cd`, nil, `abc`, []Group{{0, 2}}},
-	{`ab|cd`, nil, `abcd`, []Group{{0, 2}, {2, 4}}},
-	{`$b`, nil, `b`, []Group{}},
-	{`a\(b`, nil, `a(b`, []Group{{0, 3}}},
-	{`a\(*b`, nil, `ab`, []Group{{0, 2}}},
-	{`a\(*b`, nil, `a((b`, []Group{{0, 4}}},
-	{`a\\b`, nil, `a\b`, []Group{{0, 3}}},
-	{`a+b+c`, nil, `aabbabc`, []Group{{4, 7}}},
-	{`a{1,}b{1,}c`, nil, `aabbabc`, []Group{{4, 7}}},
-	{`)(`, nil, `-`, nil},
-	{`[^ab]*`, nil, `cde`, []Group{{0, 3}, {3, 3}}},
-	{`abc`, nil, ``, []Group{}},
-	{`a*`, nil, ``, []Group{{0, 0}}},
-	{`a|b|c|d|e`, nil, `e`, []Group{{0, 1}}},
-	{`abcd*efg`, nil, `abcdefg`, []Group{{0, 7}}},
-	{`ab*`, nil, `xabyabbbz`, []Group{{1, 3}, {4, 8}}},
-	{`ab*`, nil, `xayabbbz`, []Group{{1, 2}, {3, 7}}},
-	{`[abhgefdc]ij`, nil, `hij`, []Group{{0, 3}}},
-	{`a[bcd]*dcdcde`, nil, `adcdcde`, []Group{{0, 7}}},
-	{`a[bcd]+dcdcde`, nil, `adcdcde`, []Group{}},
-	{`[a-zA-Z_][a-zA-Z0-9_]*`, nil, `alpha`, []Group{{0, 5}}},
-	{`multiple words of text`, nil, `uh-uh`, []Group{}},
-	{`multiple words`, nil, `multiple words, yeah`, []Group{{0, 14}}},
-	{`[k]`, nil, `ab`, []Group{}},
-	{`a[-]?c`, nil, `ac`, []Group{{0, 2}}},
-	{`^(.+)?B`, nil, `AB`, []Group{{0, 2}}},
-	{`\0009`, nil, "\x009", []Group{{0, 2}}},
-	{`\141`, nil, "a", []Group{{0, 1}}},
-
-	// At this point, the python test suite has a bunch
-	// of backreference tests. Since my engine doesn't
-	// implement backreferences, I've skipped those tests.
-
-	{`*a`, nil, ``, nil},
-	{`(*)b`, nil, ``, nil},
-	{`a**`, nil, ``, nil},
-
-	{`^`, nil, `abc`, []Group{{0, 0}}},
-	{`$`, nil, `abc`, []Group{{3, 3}}},
-	{`a[b-]`, nil, `a-`, []Group{{0, 2}}},
-	{`a[b-a]`, nil, `a-`, nil},
-
-	// Case-insensitive matching tests
-	{`abc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{0, 3}}},
-	{`abc`, []ReFlag{RE_CASE_INSENSITIVE}, `XBC`, []Group{}},
-	{`abc`, []ReFlag{RE_CASE_INSENSITIVE}, `AXC`, []Group{}},
-	{`abc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABX`, []Group{}},
-	{`abc`, []ReFlag{RE_CASE_INSENSITIVE}, `XABCY`, []Group{{1, 4}}},
-	{`abc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABABC`, []Group{{2, 5}}},
-	{`ab*c`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{0, 3}}},
-	{`ab*bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{0, 3}}},
-	{`ab*bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBC`, []Group{{0, 4}}},
-	{`ab*bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBBBC`, []Group{{0, 6}}},
-	{`ab{0,}c`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBBBC`, []Group{{0, 6}}},
-	{`ab+bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBC`, []Group{{0, 4}}},
-	{`ab+bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{}},
-	{`ab+bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABQ`, []Group{}},
-	{`ab{1,}bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABQ`, []Group{}},
-	{`ab+bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBBBC`, []Group{{0, 6}}},
-	{`ab{1,}bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBBBC`, []Group{{0, 6}}},
-	{`ab{1,3}bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBBBC`, []Group{{0, 6}}},
-	{`ab{3,4}bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBBBC`, []Group{{0, 6}}},
-	{`ab{4,5}bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBBBC`, []Group{}},
-	{`ab?bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBC`, []Group{{0, 4}}},
-	{`ab?bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{0, 3}}},
-	{`ab{0,1}bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{0, 3}}},
-	{`ab?bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBBBC`, []Group{}},
-	{`ab?c`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{0, 3}}},
-	{`^abc$`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{0, 3}}},
-	{`^abc$`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCC`, []Group{}},
-	{`^abc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCC`, []Group{{0, 3}}},
-	{`^abc$`, []ReFlag{RE_CASE_INSENSITIVE}, `AABC`, []Group{}},
-	{`abc$`, []ReFlag{RE_CASE_INSENSITIVE}, `AABC`, []Group{{1, 4}}},
-	{`^`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{0, 0}}},
-	{`$`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{3, 3}}},
-	{`a.c`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{0, 3}}},
-	{`a.c`, []ReFlag{RE_CASE_INSENSITIVE}, `AXC`, []Group{{0, 3}}},
-	{`a.*c`, []ReFlag{RE_CASE_INSENSITIVE}, `AXYZC`, []Group{{0, 5}}},
-	{`a.*c`, []ReFlag{RE_CASE_INSENSITIVE}, `AXYZD`, []Group{}},
-	{`a[bc]d`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{}},
-	{`a[bc]d`, []ReFlag{RE_CASE_INSENSITIVE}, `ABD`, []Group{{0, 3}}},
-	{`a[b-d]e`, []ReFlag{RE_CASE_INSENSITIVE}, `ABD`, []Group{}},
-	{`a[b-d]e`, []ReFlag{RE_CASE_INSENSITIVE}, `ACE`, []Group{{0, 3}}},
-	{`a[b-d]`, []ReFlag{RE_CASE_INSENSITIVE}, `AAC`, []Group{{1, 3}}},
-	{`a[-b]`, []ReFlag{RE_CASE_INSENSITIVE}, `A-`, []Group{{0, 2}}}, // If a character class has a hyphen without a start or end character, it is treated as a literal hyphen
-	{`a[\-b]`, []ReFlag{RE_CASE_INSENSITIVE}, `A-`, []Group{{0, 2}}},
-	{`a[b-]`, []ReFlag{RE_CASE_INSENSITIVE}, `A-`, []Group{{0, 2}}}, // If a character class has a hyphen without a start or end character, it is treated as a literal hyphen
-
-	{`a[]b`, []ReFlag{RE_CASE_INSENSITIVE}, `-`, nil},
-	{`a[`, []ReFlag{RE_CASE_INSENSITIVE}, `-`, nil},
-	{`a\`, []ReFlag{RE_CASE_INSENSITIVE}, `-`, nil},
-	{`abc)`, []ReFlag{RE_CASE_INSENSITIVE}, `-`, nil},
-	{`(abc`, []ReFlag{RE_CASE_INSENSITIVE}, `-`, nil},
-	{`a]`, []ReFlag{RE_CASE_INSENSITIVE}, `A]`, []Group{{0, 2}}},
-	{`a[]]b`, []ReFlag{RE_CASE_INSENSITIVE}, `A]B`, []Group{{0, 3}}},
-	{`a[\]]b`, []ReFlag{RE_CASE_INSENSITIVE}, `A]B`, []Group{{0, 3}}},
-	{`a[^bc]d`, []ReFlag{RE_CASE_INSENSITIVE}, `AED`, []Group{{0, 3}}},
-	{`a[^bc]d`, []ReFlag{RE_CASE_INSENSITIVE}, `ABD`, []Group{}},
-	{`a[^-b]c`, []ReFlag{RE_CASE_INSENSITIVE}, `ADC`, []Group{{0, 3}}},
-	{`a[^-b]c`, []ReFlag{RE_CASE_INSENSITIVE}, `A-C`, []Group{}},
-	{`a[^]b]c`, []ReFlag{RE_CASE_INSENSITIVE}, `A]C`, []Group{}},
-	{`a[^]b]c`, []ReFlag{RE_CASE_INSENSITIVE}, `ADC`, []Group{{0, 3}}},
-	{`\ba\b`, []ReFlag{RE_CASE_INSENSITIVE}, `A-`, []Group{{0, 1}}},
-	{`\ba\b`, []ReFlag{RE_CASE_INSENSITIVE}, `-A`, []Group{{1, 2}}},
-	{`\ba\b`, []ReFlag{RE_CASE_INSENSITIVE}, `-A-`, []Group{{1, 2}}},
-	{`\by\b`, []ReFlag{RE_CASE_INSENSITIVE}, `XY`, []Group{}},
-	{`\by\b`, []ReFlag{RE_CASE_INSENSITIVE}, `YZ`, []Group{}},
-	{`\by\b`, []ReFlag{RE_CASE_INSENSITIVE}, `XYZ`, []Group{}},
-	{`x\b`, []ReFlag{RE_CASE_INSENSITIVE}, `XYZ`, []Group{}},
-	{`x\B`, []ReFlag{RE_CASE_INSENSITIVE}, `XYZ`, []Group{{0, 1}}},
-	{`\Bz`, []ReFlag{RE_CASE_INSENSITIVE}, `XYZ`, []Group{{2, 3}}},
-	{`z\B`, []ReFlag{RE_CASE_INSENSITIVE}, `XYZ`, []Group{}},
-	{`\Bx`, []ReFlag{RE_CASE_INSENSITIVE}, `XYZ`, []Group{}},
-	{`\Ba\B`, []ReFlag{RE_CASE_INSENSITIVE}, `A-`, []Group{}},
-	{`\Ba\B`, []ReFlag{RE_CASE_INSENSITIVE}, `-A`, []Group{}},
-	{`\Ba\B`, []ReFlag{RE_CASE_INSENSITIVE}, `-A-`, []Group{}},
-	{`\By\B`, []ReFlag{RE_CASE_INSENSITIVE}, `XY`, []Group{}},
-	{`\By\B`, []ReFlag{RE_CASE_INSENSITIVE}, `YZ`, []Group{}},
-	{`\By\b`, []ReFlag{RE_CASE_INSENSITIVE}, `XY`, []Group{{1, 2}}},
-	{`\by\B`, []ReFlag{RE_CASE_INSENSITIVE}, `YZ`, []Group{{0, 1}}},
-	{`\By\B`, []ReFlag{RE_CASE_INSENSITIVE}, `XYZ`, []Group{{1, 2}}},
-	{`ab|cd`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Group{{0, 2}}},
-	{`ab|cd`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCD`, []Group{{0, 2}, {2, 4}}},
-	{`$b`, []ReFlag{RE_CASE_INSENSITIVE}, `B`, []Group{}},
-	{`a\(b`, []ReFlag{RE_CASE_INSENSITIVE}, `A(B`, []Group{{0, 3}}},
-	{`a\(*b`, []ReFlag{RE_CASE_INSENSITIVE}, `AB`, []Group{{0, 2}}},
-	{`a\(*b`, []ReFlag{RE_CASE_INSENSITIVE}, `A((B`, []Group{{0, 4}}},
-	{`a\\b`, []ReFlag{RE_CASE_INSENSITIVE}, `A\B`, []Group{{0, 3}}},
-	{`a+b+c`, []ReFlag{RE_CASE_INSENSITIVE}, `AABBABC`, []Group{{4, 7}}},
-	{`a{1,}b{1,}c`, []ReFlag{RE_CASE_INSENSITIVE}, `AABBABC`, []Group{{4, 7}}},
-	{`)(`, []ReFlag{RE_CASE_INSENSITIVE}, `-`, nil},
-	{`[^ab]*`, []ReFlag{RE_CASE_INSENSITIVE}, `CDE`, []Group{{0, 3}, {3, 3}}},
-	{`abc`, []ReFlag{RE_CASE_INSENSITIVE}, ``, []Group{}},
-	{`a*`, []ReFlag{RE_CASE_INSENSITIVE}, ``, []Group{{0, 0}}},
-	{`a|b|c|d|e`, []ReFlag{RE_CASE_INSENSITIVE}, `E`, []Group{{0, 1}}},
-	{`abcd*efg`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCDEFG`, []Group{{0, 7}}},
-	{`ab*`, []ReFlag{RE_CASE_INSENSITIVE}, `XABYABBBZ`, []Group{{1, 3}, {4, 8}}},
-	{`ab*`, []ReFlag{RE_CASE_INSENSITIVE}, `XAYABBBZ`, []Group{{1, 2}, {3, 7}}},
-	{`[abhgefdc]ij`, []ReFlag{RE_CASE_INSENSITIVE}, `HIJ`, []Group{{0, 3}}},
-	{`a[bcd]*dcdcde`, []ReFlag{RE_CASE_INSENSITIVE}, `ADCDCDE`, []Group{{0, 7}}},
-	{`a[bcd]+dcdcde`, []ReFlag{RE_CASE_INSENSITIVE}, `ADCDCDE`, []Group{}},
-	{`[a-zA-Z_][a-zA-Z0-9_]*`, []ReFlag{RE_CASE_INSENSITIVE}, `ALPHA`, []Group{{0, 5}}},
-	{`multiple words of text`, []ReFlag{RE_CASE_INSENSITIVE}, `UH-UH`, []Group{}},
-	{`multiple words`, []ReFlag{RE_CASE_INSENSITIVE}, `MULTIPLE WORDS, YEAH`, []Group{{0, 14}}},
-	{`[k]`, []ReFlag{RE_CASE_INSENSITIVE}, `AB`, []Group{}},
-	{`a[-]?c`, []ReFlag{RE_CASE_INSENSITIVE}, `AC`, []Group{{0, 2}}},
-	{`^(.+)?B`, []ReFlag{RE_CASE_INSENSITIVE}, `ab`, []Group{{0, 2}}},
-	{`\0009`, []ReFlag{RE_CASE_INSENSITIVE}, "\x009", []Group{{0, 2}}},
-	{`\141`, []ReFlag{RE_CASE_INSENSITIVE}, "A", []Group{{0, 1}}},
-
-	{`a[-]?c`, []ReFlag{RE_CASE_INSENSITIVE}, `AC`, []Group{{0, 2}}},
-
-	{`a(?!b).`, nil, `abad`, []Group{{2, 4}}},
-	{`a(?=d).`, nil, `abad`, []Group{{2, 4}}},
-	{`a(?=c|d).`, nil, `abad`, []Group{{2, 4}}},
-
-	{`^abc`, nil, "jkl\nabc\nxyz", []Group{}},
-	{`^abc`, []ReFlag{RE_MULTILINE}, "jkl\nabc\nxyz", []Group{{4, 7}}},
-	{`abc$`, nil, "jkl\nabc\nxyz", []Group{}},
-	{`abc$`, []ReFlag{RE_MULTILINE}, "jkl\nabc\nxyz", []Group{{4, 7}}},
-	{`abc$`, []ReFlag{RE_MULTILINE}, "jkl\n123abc\nxyz", []Group{{7, 10}}},
-	{`^`, nil, "jkl\n123abc\nxyz", []Group{{0, 0}}},
-	{`^`, []ReFlag{RE_MULTILINE}, "jkl\n123abc\nxyz", []Group{{0, 0}, {4, 4}, {11, 11}}},
-	{`\A`, []ReFlag{RE_MULTILINE}, "jkl\n123abc\nxyz", []Group{{0, 0}}},
-	{`$`, nil, "jkl\n123abc\nxyz", []Group{{14, 14}}},
-	{`$`, []ReFlag{RE_MULTILINE}, "jkl\n123abc\nxyz", []Group{{3, 3}, {10, 10}, {14, 14}}},
-	{`\z`, []ReFlag{RE_MULTILINE}, "jkl\n123abc\nxyz", []Group{{14, 14}}},
-	{`^abc\z`, []ReFlag{RE_MULTILINE}, "abc\nabc\nabc", []Group{{8, 11}}},
-
-	{`a.b`, nil, "a\nb", []Group{}},
-	{`a.b`, []ReFlag{RE_SINGLE_LINE}, "a\nb", []Group{{0, 3}}},
-
-	{`\w+`, nil, `--ab_cd0123--`, []Group{{2, 11}}},
-	{`[\w]+`, nil, `--ab_cd0123--`, []Group{{2, 11}}},
-	{`\D+`, nil, `1234abc5678`, []Group{{4, 7}}},
-	{`[\D]+`, nil, `1234abc5678`, []Group{{4, 7}}},
-	{`[\D5]+`, nil, `1234abc5678`, []Group{{4, 8}}},
-	{`[\da-fA-F]+`, nil, `123abc`, []Group{{0, 6}}},
-	{`\xff`, nil, "\u00ff", []Group{{0, 1}}},
-	{`\xFF`, nil, "\u00ff", []Group{{0, 1}}},
-	{`\x00ff`, nil, "\u00ff", []Group{}},
-	{`\x{0000ff}`, nil, "\u00ff", []Group{{0, 1}}},
-	{`\x{0000FF}`, nil, "\u00ff", []Group{{0, 1}}},
-	{"\t\n\v\r\f\a", nil, "\t\n\v\r\f\a", []Group{{0, 6}}},
-	{`\t\n\v\r\f\a`, nil, "\t\n\v\r\f\a", []Group{{0, 6}}},
-	{`[\t][\n][\v][\r][\f][\b]`, nil, "\t\n\v\r\f\b", []Group{{0, 6}}},
-	{`.*d`, nil, "abc\nabd", []Group{{4, 7}}},
-	{`(`, nil, "-", nil},
-	{`[\41]`, nil, `!`, []Group{{0, 1}}},
-	{`(?<!abc)(d.f)`, nil, `abcdefdof`, []Group{{6, 9}}},
-	{`[\w-]+`, nil, `laser_beam`, []Group{{0, 10}}},
-	{`M+`, []ReFlag{RE_CASE_INSENSITIVE}, `MMM`, []Group{{0, 3}}},
-	{`m+`, []ReFlag{RE_CASE_INSENSITIVE}, `MMM`, []Group{{0, 3}}},
-	{`[M]+`, []ReFlag{RE_CASE_INSENSITIVE}, `MMM`, []Group{{0, 3}}},
-	{`[m]+`, []ReFlag{RE_CASE_INSENSITIVE}, `MMM`, []Group{{0, 3}}},
-	{`^*`, nil, `-`, nil},
-	{`a[^>]*b`, nil, `a>b`, []Group{}},
-	{`^a*$`, nil, `foo`, []Group{}},
-
-	// Out-of-bounds for character classes
-	{`[b-e]`, nil, `a`, []Group{}},
-	{`[b-e]`, nil, `f`, []Group{}},
-
-	{`*?`, nil, `-`, nil},
-	{`a*?`, nil, `-`, nil}, // non-greedy operators are not supported
-
-	// Numeric range tests - this is a feature that I added, and doesn't exist
-	// in any other mainstream regex engine
-	{`<0-255>`, nil, `0`, []Group{{0, 1}}},
-	{`<0-255>`, nil, `7`, []Group{{0, 1}}},
-	{`<0-255>`, nil, `46`, []Group{{0, 2}}},
-	{`<0-255>`, nil, `90`, []Group{{0, 2}}},
-	{`<0-255>`, nil, `107`, []Group{{0, 3}}},
-	{`<0-255>`, nil, `198`, []Group{{0, 3}}},
-	{`<0-255>`, nil, `254`, []Group{{0, 3}}},
-	{`<0-255>`, nil, `255`, []Group{{0, 3}}},
-	{`<0-255>`, nil, `256`, []Group{{0, 2}, {2, 3}}},
-	{`^<0-255>$`, nil, `256`, []Group{}},
-
-	{`^<0-299792458>$`, nil, `299000999`, []Group{{0, 9}}},
-	{`^<0-299792458>$`, nil, `299792531`, []Group{}},
-
-	{`^<3-0>$`, nil, `-`, nil},
-	{`^<0-0>$`, nil, `0`, []Group{{0, 1}}},
-	{`2<0-55>`, nil, `231`, []Group{{0, 3}}},
-	{`2<0-55>`, nil, `271`, []Group{{0, 2}}},
-	{`^2<0-55>$`, nil, `271`, []Group{}},
-
-	{`<389`, nil, `-`, nil},
-	{`<389>`, nil, `-`, nil},
-	{`<-389>`, nil, `-`, nil},
-	{`<389->`, nil, `-`, nil},
-	{`<389-400`, nil, `-`, nil},
-	{`<389-400>`, nil, `391`, []Group{{0, 3}}},
-	{`\b<1-10000>\b`, nil, `America declared independence in 1776.`, []Group{{33, 37}}},
-}
-
-var groupTests = []struct {
-	re     string
-	flags  []ReFlag
-	str    string
-	result []Match
-}{
-	{"(a)(b)", nil, "ab", []Match{[]Group{{0, 2}, {0, 1}, {1, 2}}}},
-	{"((a))(b)", nil, "ab", []Match{[]Group{{0, 2}, {0, 1}, {0, 1}, {1, 2}}}},
-	{"(0)", nil, "ab", []Match{[]Group{}}},
-	{"(a)b", nil, "ab", []Match{[]Group{{0, 2}, {0, 1}}}},
-	{"a(b)", nil, "ab", []Match{[]Group{{0, 2}, {1, 2}}}},
-	{"(a|b)", nil, "ab", []Match{[]Group{{0, 1}, {0, 1}}, []Group{{1, 2}, {1, 2}}}},
-	{"(a)|(b)", nil, "ab", []Match{[]Group{{0, 1}, {0, 1}, {-1, -1}}, []Group{{1, 2}, {-1, -1}, {1, 2}}}},
-	{"(a+)(a)", nil, "aaaa", []Match{[]Group{{0, 4}, {0, 3}, {3, 4}}}},
-	{"(a+)|(a)", nil, "aaaa", []Match{[]Group{{0, 4}, {0, 4}, {-1, -1}}}},
-	{"(a+)(aa)", nil, "aaaa", []Match{[]Group{{0, 4}, {0, 2}, {2, 4}}}},
-	{"(aaaa)|(aaaa)", nil, "aaaa", []Match{[]Group{{0, 4}, {0, 4}, {-1, -1}}}},
-	{"(aaa)|(aaaa)", nil, "aaaa", []Match{[]Group{{0, 4}, {-1, -1}, {0, 4}}}},
-	{"(aaa)|(aaaa)", nil, "aaaa", []Match{[]Group{{0, 4}, {-1, -1}, {0, 4}}}},
-	{"(aaaa)|(aaa)", nil, "aaaa", []Match{[]Group{{0, 4}, {0, 4}, {-1, -1}}}},
-	{"(a)|(aa)", nil, "aa", []Match{[]Group{{0, 2}, {-1, -1}, {0, 2}}}},
-	{"(a?)a?", nil, "b", []Match{[]Group{{0, 0}, {0, 0}}, []Group{{1, 1}, {1, 1}}}},
-	{"(a?)a?", nil, "ab", []Match{[]Group{{0, 1}, {0, 1}}, []Group{{1, 1}, {1, 1}}, []Group{{2, 2}, {2, 2}}}},
-	{"(a?)a?", nil, "aa", []Match{[]Group{{0, 2}, {0, 1}}, []Group{{2, 2}, {2, 2}}}},
-	{"a((b.d){3})", nil, "abfdbhdbid", []Match{[]Group{{0, 10}, {1, 10}, {7, 10}}}},
-
-	// Test cases from Python's RE test suite
-	{`(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\071`, nil, `abcdefghijkl9`, []Match{[]Group{{0, 13}, {0, 1}, {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8}, {8, 9}, {9, 10}, {10, 11}, {11, 12}}}},
-	{`()ef`, nil, `def`, []Match{[]Group{{1, 3}, {1, 1}}}},
-	{`(?:)ef`, nil, `def`, []Match{[]Group{{1, 3}}}},
-	{`(?:)`, nil, `def`, []Match{[]Group{{0, 0}}, []Group{{1, 1}}, []Group{{2, 2}}, []Group{{3, 3}}}},
-	{`((a))`, nil, `abc`, []Match{[]Group{{0, 1}, {0, 1}, {0, 1}}}},
-	{`(a)b(c)`, nil, `abc`, []Match{[]Group{{0, 3}, {0, 1}, {2, 3}}}},
-	{`(a+|b)*`, nil, `ab`, []Match{[]Group{{0, 2}, {1, 2}}, []Group{{2, 2}}}},
-	{`(a+|b){0,}`, nil, `ab`, []Match{[]Group{{0, 2}, {1, 2}}, []Group{{2, 2}}}},
-	{`(a+|b)+`, nil, `ab`, []Match{[]Group{{0, 2}, {1, 2}}}},
-	{`(a+|b){1,}`, nil, `ab`, []Match{[]Group{{0, 2}, {1, 2}}}},
-	{`(a+|b)?`, nil, `ab`, []Match{[]Group{{0, 1}, {0, 1}}, []Group{{1, 2}, {1, 2}}, []Group{{2, 2}}}},
-	{`(a+|b){0,1}`, nil, `ab`, []Match{[]Group{{0, 1}, {0, 1}}, []Group{{1, 2}, {1, 2}}, []Group{{2, 2}}}},
-	{`(a|b|c|d|e)f`, nil, `ef`, []Match{[]Group{{0, 2}, {0, 1}}}},
-	{`(ab|cd)e`, nil, `abcde`, []Match{[]Group{{2, 5}, {2, 4}}}},
-	{`^(ab|cd)e`, nil, `abcde`, []Match{}},
-	{`(abc|)ef`, nil, `abcdef`, []Match{[]Group{{4, 6}, {4, 4}}}},
-	{`(a|b)c*d`, nil, `abcd`, []Match{[]Group{{1, 4}, {1, 2}}}},
-	{`(ab|ab*)bc`, nil, `abc`, []Match{[]Group{{0, 3}, {0, 1}}}},
-	{`a([bc]*)c*`, nil, `abc`, []Match{[]Group{{0, 3}, {1, 3}}}},
-	{`a([bc]*)(c*d)`, nil, `abcd`, []Match{[]Group{{0, 4}, {1, 3}, {3, 4}}}},
-	{`a([bc]+)(c*d)`, nil, `abcd`, []Match{[]Group{{0, 4}, {1, 3}, {3, 4}}}},
-	{`a([bc]*)(c+d)`, nil, `abcd`, []Match{[]Group{{0, 4}, {1, 2}, {2, 4}}}},
-	{`(ab|a)b*c`, nil, `abc`, []Match{[]Group{{0, 3}, {0, 2}}}},
-	{`((a)(b)c)(d)`, nil, `abcd`, []Match{[]Group{{0, 4}, {0, 3}, {0, 1}, {1, 2}, {3, 4}}}},
-	{`^a(bc+|b[eh])g|.h$`, nil, `abh`, []Match{[]Group{{1, 3}}}},
-	{`(bc+d$|ef*g.|h?i(j|k))`, nil, `effgz`, []Match{[]Group{{0, 5}, {0, 5}}}},
-	{`(bc+d$|ef*g.|h?i(j|k))`, nil, `ij`, []Match{[]Group{{0, 2}, {0, 2}, {1, 2}}}},
-	{`(bc+d$|ef*g.|h?i(j|k))`, nil, `effg`, []Match{}},
-	{`(bc+d$|ef*g.|h?i(j|k))`, nil, `bcdd`, []Match{}},
-	{`(bc+d$|ef*g.|h?i(j|k))`, nil, `reffgz`, []Match{[]Group{{1, 6}, {1, 6}}}},
-	{`(((((((((a)))))))))`, nil, `a`, []Match{[]Group{{0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}}}},
-	{`(((((((((a)))))))))\41`, nil, `a`, []Match{[]Group{{0, 2}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}}}},
-	{`(.*)c(.*)`, nil, `abcde`, []Match{[]Group{{0, 5}, {0, 2}, {3, 5}}}},
-	{`\((.*), (.*)\)`, nil, `(a, b)`, []Match{[]Group{{0, 6}, {1, 2}, {4, 5}}}},
-
-	// At this point, the python test suite has a bunch
-	// of backreference tests. Since my engine doesn't
-	// implement backreferences, I've skipped those tests.
-
-	{`(a)(b)c|ab`, nil, `ab`, []Match{[]Group{{0, 2}}}},
-	{`(a)+x`, nil, `aaax`, []Match{[]Group{{0, 4}, {2, 3}}}},
-	{`([ac])+x`, nil, `aacx`, []Match{[]Group{{0, 4}, {2, 3}}}},
-	{`([^/]*/)*sub1/`, nil, `d:msgs/tdir/sub1/trial/away.cpp`, []Match{[]Group{{0, 17}, {7, 12}}}},
-	{`([^.]*)\.([^:]*):[T ]+(.*)`, nil, `track1.title:TBlah blah blah`, []Match{[]Group{{0, 28}, {0, 6}, {7, 12}, {14, 28}}}},
-	{`([^N]*N)+`, nil, `abNNxyzN`, []Match{[]Group{{0, 8}, {4, 8}}}},
-	{`([^N]*N)+`, nil, `abNNxyz`, []Match{[]Group{{0, 4}, {3, 4}}}},
-	{`([abc]*)x`, nil, `abcx`, []Match{[]Group{{0, 4}, {0, 3}}}},
-	{`([abc]*)x`, nil, `abc`, []Match{}},
-	{`([xyz]*)x`, nil, `abcx`, []Match{[]Group{{3, 4}, {3, 3}}}},
-	{`(a)+b|aac`, nil, `aac`, []Match{[]Group{{0, 3}}}},
-	{`([abc])*d`, nil, `abbbcd`, []Match{[]Group{{0, 6}, {4, 5}}}},
-	{`([abc])*bcd`, nil, `abcd`, []Match{[]Group{{0, 4}, {0, 1}}}},
-	{`^(ab|cd)e`, nil, `abcde`, []Match{}},
-
-	// Case-insensitive tests
-	{`(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\071`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCDEFGHIJKL9`, []Match{[]Group{{0, 13}, {0, 1}, {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8}, {8, 9}, {9, 10}, {10, 11}, {11, 12}}}},
-	{`()ef`, []ReFlag{RE_CASE_INSENSITIVE}, `DEF`, []Match{[]Group{{1, 3}, {1, 1}}}},
-	{`(?:)ef`, []ReFlag{RE_CASE_INSENSITIVE}, `DEF`, []Match{[]Group{{1, 3}}}},
-	{`(?:)`, []ReFlag{RE_CASE_INSENSITIVE}, `DEF`, []Match{[]Group{{0, 0}}, []Group{{1, 1}}, []Group{{2, 2}}, []Group{{3, 3}}}},
-	{`((a))`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Match{[]Group{{0, 1}, {0, 1}, {0, 1}}}},
-	{`(a)b(c)`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Match{[]Group{{0, 3}, {0, 1}, {2, 3}}}},
-	{`(a+|b)*`, []ReFlag{RE_CASE_INSENSITIVE}, `AB`, []Match{[]Group{{0, 2}, {1, 2}}, []Group{{2, 2}}}},
-	{`(a+|b){0,}`, []ReFlag{RE_CASE_INSENSITIVE}, `AB`, []Match{[]Group{{0, 2}, {1, 2}}, []Group{{2, 2}}}},
-	{`(a+|b)+`, []ReFlag{RE_CASE_INSENSITIVE}, `AB`, []Match{[]Group{{0, 2}, {1, 2}}}},
-	{`(a+|b){1,}`, []ReFlag{RE_CASE_INSENSITIVE}, `AB`, []Match{[]Group{{0, 2}, {1, 2}}}},
-	{`(a+|b)?`, []ReFlag{RE_CASE_INSENSITIVE}, `AB`, []Match{[]Group{{0, 1}, {0, 1}}, []Group{{1, 2}, {1, 2}}, []Group{{2, 2}}}},
-	{`(a+|b){0,1}`, []ReFlag{RE_CASE_INSENSITIVE}, `AB`, []Match{[]Group{{0, 1}, {0, 1}}, []Group{{1, 2}, {1, 2}}, []Group{{2, 2}}}},
-	{`(a|b|c|d|e)f`, []ReFlag{RE_CASE_INSENSITIVE}, `EF`, []Match{[]Group{{0, 2}, {0, 1}}}},
-	{`(ab|cd)e`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCDE`, []Match{[]Group{{2, 5}, {2, 4}}}},
-	{`^(ab|cd)e`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCDE`, []Match{}},
-	{`(abc|)ef`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCDEF`, []Match{[]Group{{4, 6}, {4, 4}}}},
-	{`(a|b)c*d`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCD`, []Match{[]Group{{1, 4}, {1, 2}}}},
-	{`(ab|ab*)bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Match{[]Group{{0, 3}, {0, 1}}}},
-	{`a([bc]*)c*`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Match{[]Group{{0, 3}, {1, 3}}}},
-	{`a([bc]*)(c*d)`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCD`, []Match{[]Group{{0, 4}, {1, 3}, {3, 4}}}},
-	{`a([bc]+)(c*d)`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCD`, []Match{[]Group{{0, 4}, {1, 3}, {3, 4}}}},
-	{`a([bc]*)(c+d)`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCD`, []Match{[]Group{{0, 4}, {1, 2}, {2, 4}}}},
-	{`(ab|a)b*c`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Match{[]Group{{0, 3}, {0, 2}}}},
-	{`((a)(b)c)(d)`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCD`, []Match{[]Group{{0, 4}, {0, 3}, {0, 1}, {1, 2}, {3, 4}}}},
-	{`^a(bc+|b[eh])g|.h$`, []ReFlag{RE_CASE_INSENSITIVE}, `ABH`, []Match{[]Group{{1, 3}}}},
-	{`(bc+d$|ef*g.|h?i(j|k))`, []ReFlag{RE_CASE_INSENSITIVE}, `EFFGZ`, []Match{[]Group{{0, 5}, {0, 5}}}},
-	{`(bc+d$|ef*g.|h?i(j|k))`, []ReFlag{RE_CASE_INSENSITIVE}, `IJ`, []Match{[]Group{{0, 2}, {0, 2}, {1, 2}}}},
-	{`(bc+d$|ef*g.|h?i(j|k))`, []ReFlag{RE_CASE_INSENSITIVE}, `EFFG`, []Match{}},
-	{`(bc+d$|ef*g.|h?i(j|k))`, []ReFlag{RE_CASE_INSENSITIVE}, `BCDD`, []Match{}},
-	{`(bc+d$|ef*g.|h?i(j|k))`, []ReFlag{RE_CASE_INSENSITIVE}, `reffgz`, []Match{[]Group{{1, 6}, {1, 6}}}},
-	{`(((((((((a)))))))))`, []ReFlag{RE_CASE_INSENSITIVE}, `A`, []Match{[]Group{{0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}}}},
-	{`(((((((((a)))))))))\41`, []ReFlag{RE_CASE_INSENSITIVE}, `A`, []Match{[]Group{{0, 2}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}}}},
-	{`(.*)c(.*)`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCDE`, []Match{[]Group{{0, 5}, {0, 2}, {3, 5}}}},
-	{`\((.*), (.*)\)`, []ReFlag{RE_CASE_INSENSITIVE}, `(A, B)`, []Match{[]Group{{0, 6}, {1, 2}, {4, 5}}}},
-	{`(a)(b)c|ab`, []ReFlag{RE_CASE_INSENSITIVE}, `AB`, []Match{[]Group{{0, 2}}}},
-	{`(a)+x`, []ReFlag{RE_CASE_INSENSITIVE}, `AAAX`, []Match{[]Group{{0, 4}, {2, 3}}}},
-	{`([ac])+x`, []ReFlag{RE_CASE_INSENSITIVE}, `AACX`, []Match{[]Group{{0, 4}, {2, 3}}}},
-	{`([^/]*/)*sub1/`, []ReFlag{RE_CASE_INSENSITIVE}, `D:MSGS/TDIR/SUB1/TRIAL/AWAY.CPP`, []Match{[]Group{{0, 17}, {7, 12}}}},
-	{`([^.]*)\.([^:]*):[T ]+(.*)`, []ReFlag{RE_CASE_INSENSITIVE}, `TRACK1.TITLE:TBLAH BLAH BLAH`, []Match{[]Group{{0, 28}, {0, 6}, {7, 12}, {14, 28}}}},
-	{`([^N]*N)+`, []ReFlag{RE_CASE_INSENSITIVE}, `ABNNXYZN`, []Match{[]Group{{0, 8}, {4, 8}}}},
-	{`([^N]*N)+`, []ReFlag{RE_CASE_INSENSITIVE}, `ABNNXYZ`, []Match{[]Group{{0, 4}, {3, 4}}}},
-	{`([abc]*)x`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCX`, []Match{[]Group{{0, 4}, {0, 3}}}},
-	{`([abc]*)x`, []ReFlag{RE_CASE_INSENSITIVE}, `ABC`, []Match{}},
-	{`([xyz]*)x`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCX`, []Match{[]Group{{3, 4}, {3, 3}}}},
-	{`(a)+b|aac`, []ReFlag{RE_CASE_INSENSITIVE}, `AAC`, []Match{[]Group{{0, 3}}}},
-	{`([abc])*d`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBBCD`, []Match{[]Group{{0, 6}, {4, 5}}}},
-	{`([abc])*bcd`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCD`, []Match{[]Group{{0, 4}, {0, 1}}}},
-	{`^(ab|cd)e`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCDE`, []Match{}},
-
-	{`(?:(?:(?:(?:(?:(?:a))))))`, nil, `a`, []Match{[]Group{{0, 1}}}},
-	{`a(?:b|c|d)(.)`, nil, `ace`, []Match{[]Group{{0, 3}, {2, 3}}}},
-	{`a(?:b|c|d)*(.)`, nil, `ace`, []Match{[]Group{{0, 3}, {2, 3}}}},
-	{`a(?:b|c|d)+(.)`, nil, `ace`, []Match{[]Group{{0, 3}, {2, 3}}}},
-	{`a(?:b|(c|e){1,2}?|d)+(.)`, nil, `ace`, []Match{[]Group{{0, 3}, {1, 2}, {2, 3}}}},
-	{`(?<!-):(.*)(?<!-):`, nil, `a:bc-:de:f`, []Match{[]Group{{1, 9}, {2, 8}}}},
-	{`(?<!\\):(.*)(?<!\\):`, nil, `a:bc\:de:f`, []Match{[]Group{{1, 9}, {2, 8}}}},
-	{`(?<!\?)'(.*)(?<!\?)'`, nil, `a'bc?'de'f`, []Match{[]Group{{1, 9}, {2, 8}}}},
-
-	{`([\s]*)([\S]*)([\s]*)`, nil, ` testing!1972`, []Match{[]Group{{0, 13}, {0, 1}, {1, 13}, {13, 13}}, []Group{{13, 13}, {13, 13}, {13, 13}, {13, 13}}}},
-	{`(\s*)(\S*)(\s*)`, nil, ` testing!1972`, []Match{[]Group{{0, 13}, {0, 1}, {1, 13}, {13, 13}}, []Group{{13, 13}, {13, 13}, {13, 13}, {13, 13}}}},
-	{`(([a-z]+):)?([a-z]+)$`, nil, `smil`, []Match{[]Group{{0, 4}, {-1, -1}, {-1, -1}, {0, 4}}}},
-
-	{`(x?)?`, nil, `x`, []Match{[]Group{{0, 1}, {0, 1}}, []Group{{1, 1}, {1, 1}}}},
-	{`"(?:\\"|[^"])*"`, nil, `"\""`, []Match{[]Group{{0, 4}}}},
-
-	{`^((a)c)?(ab)$`, nil, `ab`, []Match{[]Group{{0, 2}, {-1, -1}, {-1, -1}, {0, 2}}}},
-
-	{`^([ab]*)(?=(b)?)c`, nil, `abc`, []Match{[]Group{{0, 3}, {0, 2}}}},
-	{`^([ab]*)(?!(b))c`, nil, `abc`, []Match{[]Group{{0, 3}, {0, 2}}}},
-	{`^([ab]*)(?<!(a))c`, nil, `abc`, []Match{[]Group{{0, 3}, {0, 2}}}},
-
-	{`(<389-400>)`, nil, `391`, []Match{[]Group{{0, 3}, {0, 3}}}},
-
-	// // Tests from https://wiki.haskell.org/Regex_Posix
-	// {`(()|.)(b)`, nil, `ab`, []Match{[]Group{{0, 2}, {0, 1}, {-1, -1}, {1, 2}}}},
-	// {`(()|[ab])(b)`, nil, `ab`, []Match{[]Group{{0, 2}, {0, 1}, {-1, -1}, {1, 2}}}},
-	// {`(()|[ab])+b`, nil, `aaab`, []Match{[]Group{{0, 4}, {2, 3}, {-1, -1}}}},
-	// {`([ab]|())+b`, nil, `aaab`, []Match{[]Group{{0, 4}, {2, 3}, {-1, -1}}}},
-	// // Bug - this should give {0,6},{3,6},{-1,-1} but it gives {0,6},{3,6},{3,3}
-	// //	{`yyyyyy`, nil, `(yyy|(x?)){2,4}`, []Match{[]Group{{0, 6}, {3, 6}, {-1, -1}}, []Group{{6, 6}, {6, 6}, {6, 6}}}},
-	// {`(a|ab|c|bcd)*(d*)`, nil, `ababcd`, []Match{[]Group{{0, 6}, {3, 6}, {6, 6}}, []Group{{6, 6}, {6, 6}, {6, 6}}}},
-	// // Bug - this should give {0,3},{0,3},{0,0},{0,3},{3,3} but it gives {0,3},{0,2},{0,1},{1,2},{2,3}
-	// //	{`((a*)(b|abc))(c*)`, nil, `abc`, []Match{[]Group{{0, 3}, {0, 3}, {0, 0}, {0, 3}, {3, 3}}}},
-}
-
-func TestFind(t *testing.T) {
-	for _, test := range reTests {
-		t.Run(test.re+"	"+test.str, func(t *testing.T) {
-			regComp, err := Compile(test.re, test.flags...)
-			if err != nil {
-				if test.result != nil {
-					panic(fmt.Errorf("Test Error: %v", err))
-				}
-			} else {
-				groupIndex, err := regComp.Find(test.str)
-				if err != nil { // No matches found
-					if len(test.result) == 0 {
-						return // Manually pass the test, because this is the expected behavior
-					} else {
-						t.Errorf("Wanted no match Got %v\n", groupIndex)
-					}
-				} else {
-					if groupIndex != test.result[0] {
-						t.Errorf("Wanted %v	Got %v\n", test.result, groupIndex)
-					}
-				}
-			}
-		})
-	}
-}
-
-func TestFindAll(t *testing.T) {
-	for _, test := range reTests {
-		t.Run(test.re+"	"+test.str, func(t *testing.T) {
-			regComp, err := Compile(test.re, test.flags...)
-			if err != nil {
-				if test.result != nil {
-					panic(fmt.Errorf("Test Error: %v", err))
-				}
-			} else {
-				matchIndices := regComp.FindAll(test.str)
-				if !slices.Equal(test.result, matchIndices) {
-					t.Errorf("Wanted %v	Got %v\n", test.result, matchIndices)
-				}
-			}
-		})
-	}
-}
-
-func TestFindString(t *testing.T) {
-	for _, test := range reTests {
-		t.Run(test.re+"	"+test.str, func(t *testing.T) {
-			regComp, err := Compile(test.re, test.flags...)
-			if err != nil {
-				if test.result != nil {
-					panic(err)
-				}
-			} else {
-				foundString := regComp.FindString(test.str)
-				if len(test.result) == 0 {
-					if foundString != "" {
-						t.Errorf("Expected no match got %v\n", foundString)
-					}
-				} else {
-					expectedString := test.str[test.result[0].StartIdx:test.result[0].EndIdx]
-					if foundString != expectedString {
-						t.Errorf("Wanted %v	Got %v\n", expectedString, foundString)
-					}
-				}
-			}
-		})
-	}
-}
-
-func TestFindAllString(t *testing.T) {
-	for _, test := range reTests {
-		t.Run(test.re+"	"+test.str, func(t *testing.T) {
-			regComp, err := Compile(test.re, test.flags...)
-			if err != nil {
-				if test.result != nil {
-					panic(err)
-				}
-			} else {
-				foundStrings := regComp.FindAllString(test.str)
-				if len(test.result) != len(foundStrings) {
-					t.Errorf("Differing number of matches: Wanted %v matches Got %v matches\n", len(test.result), len(foundStrings))
-				} else {
-					for idx, group := range test.result {
-						groupStr := test.str[group.StartIdx:group.EndIdx]
-						if groupStr != foundStrings[idx] {
-							t.Errorf("Wanted %v	Got %v\n", groupStr, foundStrings[idx])
-						}
-					}
-				}
-			}
-		})
-	}
-}
-
-func TestFindSubmatch(t *testing.T) {
-	for _, test := range groupTests {
-		t.Run(test.re+"	"+test.str, func(t *testing.T) {
-			regComp, err := Compile(test.re, test.flags...)
-			if err != nil {
-				if test.result != nil {
-					panic(err)
-				}
-			}
-			match, err := regComp.FindSubmatch(test.str)
-			for i := range match {
-				if match[i].IsValid() {
-					if test.result[0][i] != match[i] {
-						t.Errorf("Wanted %v	Got %v\n", test.result[0], match)
-					}
-				}
-			}
-		})
-	}
-}
-func TestFindAllSubmatch(t *testing.T) {
-	for _, test := range groupTests {
-		t.Run(test.re+"	"+test.str, func(t *testing.T) {
-			regComp, err := Compile(test.re, test.flags...)
-			if err != nil {
-				if test.result != nil {
-					panic(err)
-				}
-			}
-			matchIndices := regComp.FindAllSubmatch(test.str)
-			for i := range matchIndices {
-				for j := range matchIndices[i] {
-					if matchIndices[i][j].IsValid() {
-						if test.result[i][j] != matchIndices[i][j] {
-							t.Errorf("Wanted %v	Got %v\n", test.result, matchIndices)
-						}
-					}
-				}
-			}
-		})
-	}
-}

regex/re_tests.py

@@ -1,670 +0,0 @@
-#!/usr/bin/env python3
-# -*- mode: python -*-
-
-# Re test suite and benchmark suite v1.5
-
-# The 3 possible outcomes for each pattern
-[SUCCEED, FAIL, SYNTAX_ERROR] = range(3)
-
-# Benchmark suite (needs expansion)
-#
-# The benchmark suite does not test correctness, just speed.  The
-# first element of each tuple is the regex pattern; the second is a
-# string to match it against.  The benchmarking code will embed the
-# second string inside several sizes of padding, to test how regex
-# matching performs on large strings.
-
-benchmarks = [
-
-    # test common prefix
-    ('Python|Perl', 'Perl'),    # Alternation
-    ('(Python|Perl)', 'Perl'),  # Grouped alternation
-
-    ('Python|Perl|Tcl', 'Perl'),        # Alternation
-    ('(Python|Perl|Tcl)', 'Perl'),      # Grouped alternation
-
-    ('(Python)\\1', 'PythonPython'),    # Backreference
-    ('([0a-z][a-z0-9]*,)+', 'a5,b7,c9,'), # Disable the fastmap optimization
-    ('([a-z][a-z0-9]*,)+', 'a5,b7,c9,'), # A few sets
-
-    ('Python', 'Python'),               # Simple text literal
-    ('.*Python', 'Python'),             # Bad text literal
-    ('.*Python.*', 'Python'),           # Worse text literal
-    ('.*(Python)', 'Python'),           # Bad text literal with grouping
-
-]
-
-# Test suite (for verifying correctness)
-#
-# The test suite is a list of 5- or 3-tuples.  The 5 parts of a
-# complete tuple are:
-# element 0: a string containing the pattern
-#         1: the string to match against the pattern
-#         2: the expected result (SUCCEED, FAIL, SYNTAX_ERROR)
-#         3: a string that will be eval()'ed to produce a test string.
-#            This is an arbitrary Python expression; the available
-#            variables are "found" (the whole match), and "g1", "g2", ...
-#            up to "g99" contain the contents of each group, or the
-#            string 'None' if the group wasn't given a value, or the
-#            string 'Error' if the group index was out of range;
-#            also "groups", the return value of m.group() (a tuple).
-#         4: The expected result of evaluating the expression.
-#            If the two don't match, an error is reported.
-#
-# If the regex isn't expected to work, the latter two elements can be omitted.
-
-tests = [
-    # Test ?P< and ?P= extensions
-    ('(?P<foo_123', '', SYNTAX_ERROR),      # Unterminated group identifier
-    ('(?P<1>a)', '', SYNTAX_ERROR),         # Begins with a digit
-    ('(?P<!>a)', '', SYNTAX_ERROR),         # Begins with an illegal char
-    ('(?P<foo!>a)', '', SYNTAX_ERROR),      # Begins with an illegal char
-
-    # Same tests, for the ?P= form
-    ('(?P<foo_123>a)(?P=foo_123', 'aa', SYNTAX_ERROR),
-    ('(?P<foo_123>a)(?P=1)', 'aa', SYNTAX_ERROR),
-    ('(?P<foo_123>a)(?P=!)', 'aa', SYNTAX_ERROR),
-    ('(?P<foo_123>a)(?P=foo_124', 'aa', SYNTAX_ERROR),  # Backref to undefined group
-
-    ('(?P<foo_123>a)', 'a', SUCCEED, 'g1', 'a'),
-    ('(?P<foo_123>a)(?P=foo_123)', 'aa', SUCCEED, 'g1', 'a'),
-
-    # Test octal escapes
-    ('\\1', 'a', SYNTAX_ERROR),    # Backreference
-    ('[\\1]', '\1', SUCCEED, 'found', '\1'),  # Character
-    ('\\09', chr(0) + '9', SUCCEED, 'found', chr(0) + '9'),
-    ('\\141', 'a', SUCCEED, 'found', 'a'),
-    ('(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\\119', 'abcdefghijklk9', SUCCEED, 'found+"-"+g11', 'abcdefghijklk9-k'),
-
-    # Test \0 is handled everywhere
-    (r'\0', '\0', SUCCEED, 'found', '\0'),
-    (r'[\0a]', '\0', SUCCEED, 'found', '\0'),
-    (r'[a\0]', '\0', SUCCEED, 'found', '\0'),
-    (r'[^a\0]', '\0', FAIL),
-
-    # Test various letter escapes
-    (r'\a[\b]\f\n\r\t\v', '\a\b\f\n\r\t\v', SUCCEED, 'found', '\a\b\f\n\r\t\v'),
-    (r'[\a][\b][\f][\n][\r][\t][\v]', '\a\b\f\n\r\t\v', SUCCEED, 'found', '\a\b\f\n\r\t\v'),
-    # NOTE: not an error under PCRE/PRE:
-    # (r'\u', '', SYNTAX_ERROR),    # A Perl escape
-    (r'\c\e\g\h\i\j\k\m\o\p\q\y\z', 'ceghijkmopqyz', SUCCEED, 'found', 'ceghijkmopqyz'),
-    (r'\xff', '\377', SUCCEED, 'found', chr(255)),
-    # new \x semantics
-    (r'\x00ffffffffffffff', '\377', FAIL, 'found', chr(255)),
-    (r'\x00f', '\017', FAIL, 'found', chr(15)),
-    (r'\x00fe', '\376', FAIL, 'found', chr(254)),
-    # (r'\x00ffffffffffffff', '\377', SUCCEED, 'found', chr(255)),
-    # (r'\x00f', '\017', SUCCEED, 'found', chr(15)),
-    # (r'\x00fe', '\376', SUCCEED, 'found', chr(254)),
-
-    (r"^\w+=(\\[\000-\277]|[^\n\\])*", "SRC=eval.c g.c blah blah blah \\\\\n\tapes.c",
-     SUCCEED, 'found', "SRC=eval.c g.c blah blah blah \\\\"),
-
-    # Test that . only matches \n in DOTALL mode
-    ('a.b', 'acb', SUCCEED, 'found', 'acb'),
-    ('a.b', 'a\nb', FAIL),
-    ('a.*b', 'acc\nccb', FAIL),
-    ('a.{4,5}b', 'acc\nccb', FAIL),
-    ('a.b', 'a\rb', SUCCEED, 'found', 'a\rb'),
-    ('a.b(?s)', 'a\nb', SUCCEED, 'found', 'a\nb'),
-    ('a.*(?s)b', 'acc\nccb', SUCCEED, 'found', 'acc\nccb'),
-    ('(?s)a.{4,5}b', 'acc\nccb', SUCCEED, 'found', 'acc\nccb'),
-    ('(?s)a.b', 'a\nb', SUCCEED, 'found', 'a\nb'),
-
-    (')', '', SYNTAX_ERROR),           # Unmatched right bracket
-    ('', '', SUCCEED, 'found', ''),    # Empty pattern
-    ('abc', 'abc', SUCCEED, 'found', 'abc'),
-    ('abc', 'xbc', FAIL),
-    ('abc', 'axc', FAIL),
-    ('abc', 'abx', FAIL),
-    ('abc', 'xabcy', SUCCEED, 'found', 'abc'),
-    ('abc', 'ababc', SUCCEED, 'found', 'abc'),
-    ('ab*c', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab*bc', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab*bc', 'abbc', SUCCEED, 'found', 'abbc'),
-    ('ab*bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab+bc', 'abbc', SUCCEED, 'found', 'abbc'),
-    ('ab+bc', 'abc', FAIL),
-    ('ab+bc', 'abq', FAIL),
-    ('ab+bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab?bc', 'abbc', SUCCEED, 'found', 'abbc'),
-    ('ab?bc', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab?bc', 'abbbbc', FAIL),
-    ('ab?c', 'abc', SUCCEED, 'found', 'abc'),
-    ('^abc$', 'abc', SUCCEED, 'found', 'abc'),
-    ('^abc$', 'abcc', FAIL),
-    ('^abc', 'abcc', SUCCEED, 'found', 'abc'),
-    ('^abc$', 'aabc', FAIL),
-    ('abc$', 'aabc', SUCCEED, 'found', 'abc'),
-    ('^', 'abc', SUCCEED, 'found+"-"', '-'),
-    ('$', 'abc', SUCCEED, 'found+"-"', '-'),
-    ('a.c', 'abc', SUCCEED, 'found', 'abc'),
-    ('a.c', 'axc', SUCCEED, 'found', 'axc'),
-    ('a.*c', 'axyzc', SUCCEED, 'found', 'axyzc'),
-    ('a.*c', 'axyzd', FAIL),
-    ('a[bc]d', 'abc', FAIL),
-    ('a[bc]d', 'abd', SUCCEED, 'found', 'abd'),
-    ('a[b-d]e', 'abd', FAIL),
-    ('a[b-d]e', 'ace', SUCCEED, 'found', 'ace'),
-    ('a[b-d]', 'aac', SUCCEED, 'found', 'ac'),
-    ('a[-b]', 'a-', SUCCEED, 'found', 'a-'),
-    ('a[\\-b]', 'a-', SUCCEED, 'found', 'a-'),
-    # NOTE: not an error under PCRE/PRE:
-    # ('a[b-]', 'a-', SYNTAX_ERROR),
-    ('a[]b', '-', SYNTAX_ERROR),
-    ('a[', '-', SYNTAX_ERROR),
-    ('a\\', '-', SYNTAX_ERROR),
-    ('abc)', '-', SYNTAX_ERROR),
-    ('(abc', '-', SYNTAX_ERROR),
-    ('a]', 'a]', SUCCEED, 'found', 'a]'),
-    ('a[]]b', 'a]b', SUCCEED, 'found', 'a]b'),
-    ('a[\]]b', 'a]b', SUCCEED, 'found', 'a]b'),
-    ('a[^bc]d', 'aed', SUCCEED, 'found', 'aed'),
-    ('a[^bc]d', 'abd', FAIL),
-    ('a[^-b]c', 'adc', SUCCEED, 'found', 'adc'),
-    ('a[^-b]c', 'a-c', FAIL),
-    ('a[^]b]c', 'a]c', FAIL),
-    ('a[^]b]c', 'adc', SUCCEED, 'found', 'adc'),
-    ('\\ba\\b', 'a-', SUCCEED, '"-"', '-'),
-    ('\\ba\\b', '-a', SUCCEED, '"-"', '-'),
-    ('\\ba\\b', '-a-', SUCCEED, '"-"', '-'),
-    ('\\by\\b', 'xy', FAIL),
-    ('\\by\\b', 'yz', FAIL),
-    ('\\by\\b', 'xyz', FAIL),
-    ('x\\b', 'xyz', FAIL),
-    ('x\\B', 'xyz', SUCCEED, '"-"', '-'),
-    ('\\Bz', 'xyz', SUCCEED, '"-"', '-'),
-    ('z\\B', 'xyz', FAIL),
-    ('\\Bx', 'xyz', FAIL),
-    ('\\Ba\\B', 'a-', FAIL, '"-"', '-'),
-    ('\\Ba\\B', '-a', FAIL, '"-"', '-'),
-    ('\\Ba\\B', '-a-', FAIL, '"-"', '-'),
-    ('\\By\\B', 'xy', FAIL),
-    ('\\By\\B', 'yz', FAIL),
-    ('\\By\\b', 'xy', SUCCEED, '"-"', '-'),
-    ('\\by\\B', 'yz', SUCCEED, '"-"', '-'),
-    ('\\By\\B', 'xyz', SUCCEED, '"-"', '-'),
-    ('ab|cd', 'abc', SUCCEED, 'found', 'ab'),
-    ('ab|cd', 'abcd', SUCCEED, 'found', 'ab'),
-    ('()ef', 'def', SUCCEED, 'found+"-"+g1', 'ef-'),
-    ('$b', 'b', FAIL),
-    ('a\\(b', 'a(b', SUCCEED, 'found+"-"+g1', 'a(b-Error'),
-    ('a\\(*b', 'ab', SUCCEED, 'found', 'ab'),
-    ('a\\(*b', 'a((b', SUCCEED, 'found', 'a((b'),
-    ('a\\\\b', 'a\\b', SUCCEED, 'found', 'a\\b'),
-    ('((a))', 'abc', SUCCEED, 'found+"-"+g1+"-"+g2', 'a-a-a'),
-    ('(a)b(c)', 'abc', SUCCEED, 'found+"-"+g1+"-"+g2', 'abc-a-c'),
-    ('a+b+c', 'aabbabc', SUCCEED, 'found', 'abc'),
-    ('(a+|b)*', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
-    ('(a+|b)+', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
-    ('(a+|b)?', 'ab', SUCCEED, 'found+"-"+g1', 'a-a'),
-    (')(', '-', SYNTAX_ERROR),
-    ('[^ab]*', 'cde', SUCCEED, 'found', 'cde'),
-    ('abc', '', FAIL),
-    ('a*', '', SUCCEED, 'found', ''),
-    ('a|b|c|d|e', 'e', SUCCEED, 'found', 'e'),
-    ('(a|b|c|d|e)f', 'ef', SUCCEED, 'found+"-"+g1', 'ef-e'),
-    ('abcd*efg', 'abcdefg', SUCCEED, 'found', 'abcdefg'),
-    ('ab*', 'xabyabbbz', SUCCEED, 'found', 'ab'),
-    ('ab*', 'xayabbbz', SUCCEED, 'found', 'a'),
-    ('(ab|cd)e', 'abcde', SUCCEED, 'found+"-"+g1', 'cde-cd'),
-    ('[abhgefdc]ij', 'hij', SUCCEED, 'found', 'hij'),
-    ('^(ab|cd)e', 'abcde', FAIL, 'xg1y', 'xy'),
-    ('(abc|)ef', 'abcdef', SUCCEED, 'found+"-"+g1', 'ef-'),
-    ('(a|b)c*d', 'abcd', SUCCEED, 'found+"-"+g1', 'bcd-b'),
-    ('(ab|ab*)bc', 'abc', SUCCEED, 'found+"-"+g1', 'abc-a'),
-    ('a([bc]*)c*', 'abc', SUCCEED, 'found+"-"+g1', 'abc-bc'),
-    ('a([bc]*)(c*d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
-    ('a([bc]+)(c*d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
-    ('a([bc]*)(c+d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-b-cd'),
-    ('a[bcd]*dcdcde', 'adcdcde', SUCCEED, 'found', 'adcdcde'),
-    ('a[bcd]+dcdcde', 'adcdcde', FAIL),
-    ('(ab|a)b*c', 'abc', SUCCEED, 'found+"-"+g1', 'abc-ab'),
-    ('((a)(b)c)(d)', 'abcd', SUCCEED, 'g1+"-"+g2+"-"+g3+"-"+g4', 'abc-a-b-d'),
-    ('[a-zA-Z_][a-zA-Z0-9_]*', 'alpha', SUCCEED, 'found', 'alpha'),
-    ('^a(bc+|b[eh])g|.h$', 'abh', SUCCEED, 'found+"-"+g1', 'bh-None'),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'effgz', SUCCEED, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'ij', SUCCEED, 'found+"-"+g1+"-"+g2', 'ij-ij-j'),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'effg', FAIL),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'bcdd', FAIL),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'reffgz', SUCCEED, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
-    ('(((((((((a)))))))))', 'a', SUCCEED, 'found', 'a'),
-    ('multiple words of text', 'uh-uh', FAIL),
-    ('multiple words', 'multiple words, yeah', SUCCEED, 'found', 'multiple words'),
-    ('(.*)c(.*)', 'abcde', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcde-ab-de'),
-    ('\\((.*), (.*)\\)', '(a, b)', SUCCEED, 'g2+"-"+g1', 'b-a'),
-    ('[k]', 'ab', FAIL),
-    ('a[-]?c', 'ac', SUCCEED, 'found', 'ac'),
-    ('(abc)\\1', 'abcabc', SUCCEED, 'g1', 'abc'),
-    ('([a-c]*)\\1', 'abcabc', SUCCEED, 'g1', 'abc'),
-    ('^(.+)?B', 'AB', SUCCEED, 'g1', 'A'),
-    ('(a+).\\1$', 'aaaaa', SUCCEED, 'found+"-"+g1', 'aaaaa-aa'),
-    ('^(a+).\\1$', 'aaaa', FAIL),
-    ('(abc)\\1', 'abcabc', SUCCEED, 'found+"-"+g1', 'abcabc-abc'),
-    ('([a-c]+)\\1', 'abcabc', SUCCEED, 'found+"-"+g1', 'abcabc-abc'),
-    ('(a)\\1', 'aa', SUCCEED, 'found+"-"+g1', 'aa-a'),
-    ('(a+)\\1', 'aa', SUCCEED, 'found+"-"+g1', 'aa-a'),
-    ('(a+)+\\1', 'aa', SUCCEED, 'found+"-"+g1', 'aa-a'),
-    ('(a).+\\1', 'aba', SUCCEED, 'found+"-"+g1', 'aba-a'),
-    ('(a)ba*\\1', 'aba', SUCCEED, 'found+"-"+g1', 'aba-a'),
-    ('(aa|a)a\\1$', 'aaa', SUCCEED, 'found+"-"+g1', 'aaa-a'),
-    ('(a|aa)a\\1$', 'aaa', SUCCEED, 'found+"-"+g1', 'aaa-a'),
-    ('(a+)a\\1$', 'aaa', SUCCEED, 'found+"-"+g1', 'aaa-a'),
-    ('([abc]*)\\1', 'abcabc', SUCCEED, 'found+"-"+g1', 'abcabc-abc'),
-    ('(a)(b)c|ab', 'ab', SUCCEED, 'found+"-"+g1+"-"+g2', 'ab-None-None'),
-    ('(a)+x', 'aaax', SUCCEED, 'found+"-"+g1', 'aaax-a'),
-    ('([ac])+x', 'aacx', SUCCEED, 'found+"-"+g1', 'aacx-c'),
-    ('([^/]*/)*sub1/', 'd:msgs/tdir/sub1/trial/away.cpp', SUCCEED, 'found+"-"+g1', 'd:msgs/tdir/sub1/-tdir/'),
-    ('([^.]*)\\.([^:]*):[T ]+(.*)', 'track1.title:TBlah blah blah', SUCCEED, 'found+"-"+g1+"-"+g2+"-"+g3', 'track1.title:TBlah blah blah-track1-title-Blah blah blah'),
-    ('([^N]*N)+', 'abNNxyzN', SUCCEED, 'found+"-"+g1', 'abNNxyzN-xyzN'),
-    ('([^N]*N)+', 'abNNxyz', SUCCEED, 'found+"-"+g1', 'abNN-N'),
-    ('([abc]*)x', 'abcx', SUCCEED, 'found+"-"+g1', 'abcx-abc'),
-    ('([abc]*)x', 'abc', FAIL),
-    ('([xyz]*)x', 'abcx', SUCCEED, 'found+"-"+g1', 'x-'),
-    ('(a)+b|aac', 'aac', SUCCEED, 'found+"-"+g1', 'aac-None'),
-
-    # Test symbolic groups
-
-    ('(?P<i d>aaa)a', 'aaaa', SYNTAX_ERROR),
-    ('(?P<id>aaa)a', 'aaaa', SUCCEED, 'found+"-"+id', 'aaaa-aaa'),
-    ('(?P<id>aa)(?P=id)', 'aaaa', SUCCEED, 'found+"-"+id', 'aaaa-aa'),
-    ('(?P<id>aa)(?P=xd)', 'aaaa', SYNTAX_ERROR),
-
-    # Test octal escapes/memory references
-
-    ('\\1', 'a', SYNTAX_ERROR),
-    ('\\09', chr(0) + '9', SUCCEED, 'found', chr(0) + '9'),
-    ('\\141', 'a', SUCCEED, 'found', 'a'),
-    ('(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\\119', 'abcdefghijklk9', SUCCEED, 'found+"-"+g11', 'abcdefghijklk9-k'),
-
-    # All tests from Perl
-
-    ('abc', 'abc', SUCCEED, 'found', 'abc'),
-    ('abc', 'xbc', FAIL),
-    ('abc', 'axc', FAIL),
-    ('abc', 'abx', FAIL),
-    ('abc', 'xabcy', SUCCEED, 'found', 'abc'),
-    ('abc', 'ababc', SUCCEED, 'found', 'abc'),
-    ('ab*c', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab*bc', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab*bc', 'abbc', SUCCEED, 'found', 'abbc'),
-    ('ab*bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab{0,}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab+bc', 'abbc', SUCCEED, 'found', 'abbc'),
-    ('ab+bc', 'abc', FAIL),
-    ('ab+bc', 'abq', FAIL),
-    ('ab{1,}bc', 'abq', FAIL),
-    ('ab+bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab{1,}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab{1,3}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab{3,4}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab{4,5}bc', 'abbbbc', FAIL),
-    ('ab?bc', 'abbc', SUCCEED, 'found', 'abbc'),
-    ('ab?bc', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab{0,1}bc', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab?bc', 'abbbbc', FAIL),
-    ('ab?c', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab{0,1}c', 'abc', SUCCEED, 'found', 'abc'),
-    ('^abc$', 'abc', SUCCEED, 'found', 'abc'),
-    ('^abc$', 'abcc', FAIL),
-    ('^abc', 'abcc', SUCCEED, 'found', 'abc'),
-    ('^abc$', 'aabc', FAIL),
-    ('abc$', 'aabc', SUCCEED, 'found', 'abc'),
-    ('^', 'abc', SUCCEED, 'found', ''),
-    ('$', 'abc', SUCCEED, 'found', ''),
-    ('a.c', 'abc', SUCCEED, 'found', 'abc'),
-    ('a.c', 'axc', SUCCEED, 'found', 'axc'),
-    ('a.*c', 'axyzc', SUCCEED, 'found', 'axyzc'),
-    ('a.*c', 'axyzd', FAIL),
-    ('a[bc]d', 'abc', FAIL),
-    ('a[bc]d', 'abd', SUCCEED, 'found', 'abd'),
-    ('a[b-d]e', 'abd', FAIL),
-    ('a[b-d]e', 'ace', SUCCEED, 'found', 'ace'),
-    ('a[b-d]', 'aac', SUCCEED, 'found', 'ac'),
-    ('a[-b]', 'a-', SUCCEED, 'found', 'a-'),
-    ('a[b-]', 'a-', SUCCEED, 'found', 'a-'),
-    ('a[b-a]', '-', SYNTAX_ERROR),
-    ('a[]b', '-', SYNTAX_ERROR),
-    ('a[', '-', SYNTAX_ERROR),
-    ('a]', 'a]', SUCCEED, 'found', 'a]'),
-    ('a[]]b', 'a]b', SUCCEED, 'found', 'a]b'),
-    ('a[^bc]d', 'aed', SUCCEED, 'found', 'aed'),
-    ('a[^bc]d', 'abd', FAIL),
-    ('a[^-b]c', 'adc', SUCCEED, 'found', 'adc'),
-    ('a[^-b]c', 'a-c', FAIL),
-    ('a[^]b]c', 'a]c', FAIL),
-    ('a[^]b]c', 'adc', SUCCEED, 'found', 'adc'),
-    ('ab|cd', 'abc', SUCCEED, 'found', 'ab'),
-    ('ab|cd', 'abcd', SUCCEED, 'found', 'ab'),
-    ('()ef', 'def', SUCCEED, 'found+"-"+g1', 'ef-'),
-    ('*a', '-', SYNTAX_ERROR),
-    ('(*)b', '-', SYNTAX_ERROR),
-    ('$b', 'b', FAIL),
-    ('a\\', '-', SYNTAX_ERROR),
-    ('a\\(b', 'a(b', SUCCEED, 'found+"-"+g1', 'a(b-Error'),
-    ('a\\(*b', 'ab', SUCCEED, 'found', 'ab'),
-    ('a\\(*b', 'a((b', SUCCEED, 'found', 'a((b'),
-    ('a\\\\b', 'a\\b', SUCCEED, 'found', 'a\\b'),
-    ('abc)', '-', SYNTAX_ERROR),
-    ('(abc', '-', SYNTAX_ERROR),
-    ('((a))', 'abc', SUCCEED, 'found+"-"+g1+"-"+g2', 'a-a-a'),
-    ('(a)b(c)', 'abc', SUCCEED, 'found+"-"+g1+"-"+g2', 'abc-a-c'),
-    ('a+b+c', 'aabbabc', SUCCEED, 'found', 'abc'),
-    ('a{1,}b{1,}c', 'aabbabc', SUCCEED, 'found', 'abc'),
-    ('a**', '-', SYNTAX_ERROR),
-    ('a.+?c', 'abcabc', SUCCEED, 'found', 'abc'),
-    ('(a+|b)*', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
-    ('(a+|b){0,}', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
-    ('(a+|b)+', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
-    ('(a+|b){1,}', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
-    ('(a+|b)?', 'ab', SUCCEED, 'found+"-"+g1', 'a-a'),
-    ('(a+|b){0,1}', 'ab', SUCCEED, 'found+"-"+g1', 'a-a'),
-    (')(', '-', SYNTAX_ERROR),
-    ('[^ab]*', 'cde', SUCCEED, 'found', 'cde'),
-    ('abc', '', FAIL),
-    ('a*', '', SUCCEED, 'found', ''),
-    ('([abc])*d', 'abbbcd', SUCCEED, 'found+"-"+g1', 'abbbcd-c'),
-    ('([abc])*bcd', 'abcd', SUCCEED, 'found+"-"+g1', 'abcd-a'),
-    ('a|b|c|d|e', 'e', SUCCEED, 'found', 'e'),
-    ('(a|b|c|d|e)f', 'ef', SUCCEED, 'found+"-"+g1', 'ef-e'),
-    ('abcd*efg', 'abcdefg', SUCCEED, 'found', 'abcdefg'),
-    ('ab*', 'xabyabbbz', SUCCEED, 'found', 'ab'),
-    ('ab*', 'xayabbbz', SUCCEED, 'found', 'a'),
-    ('(ab|cd)e', 'abcde', SUCCEED, 'found+"-"+g1', 'cde-cd'),
-    ('[abhgefdc]ij', 'hij', SUCCEED, 'found', 'hij'),
-    ('^(ab|cd)e', 'abcde', FAIL),
-    ('(abc|)ef', 'abcdef', SUCCEED, 'found+"-"+g1', 'ef-'),
-    ('(a|b)c*d', 'abcd', SUCCEED, 'found+"-"+g1', 'bcd-b'),
-    ('(ab|ab*)bc', 'abc', SUCCEED, 'found+"-"+g1', 'abc-a'),
-    ('a([bc]*)c*', 'abc', SUCCEED, 'found+"-"+g1', 'abc-bc'),
-    ('a([bc]*)(c*d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
-    ('a([bc]+)(c*d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
-    ('a([bc]*)(c+d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-b-cd'),
-    ('a[bcd]*dcdcde', 'adcdcde', SUCCEED, 'found', 'adcdcde'),
-    ('a[bcd]+dcdcde', 'adcdcde', FAIL),
-    ('(ab|a)b*c', 'abc', SUCCEED, 'found+"-"+g1', 'abc-ab'),
-    ('((a)(b)c)(d)', 'abcd', SUCCEED, 'g1+"-"+g2+"-"+g3+"-"+g4', 'abc-a-b-d'),
-    ('[a-zA-Z_][a-zA-Z0-9_]*', 'alpha', SUCCEED, 'found', 'alpha'),
-    ('^a(bc+|b[eh])g|.h$', 'abh', SUCCEED, 'found+"-"+g1', 'bh-None'),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'effgz', SUCCEED, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'ij', SUCCEED, 'found+"-"+g1+"-"+g2', 'ij-ij-j'),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'effg', FAIL),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'bcdd', FAIL),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'reffgz', SUCCEED, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
-    ('((((((((((a))))))))))', 'a', SUCCEED, 'g10', 'a'),
-    ('((((((((((a))))))))))\\10', 'aa', SUCCEED, 'found', 'aa'),
-# Python does not have the same rules for \\41 so this is a syntax error
-#    ('((((((((((a))))))))))\\41', 'aa', FAIL),
-#    ('((((((((((a))))))))))\\41', 'a!', SUCCEED, 'found', 'a!'),
-    ('((((((((((a))))))))))\\41', '', SYNTAX_ERROR),
-    ('(?i)((((((((((a))))))))))\\41', '', SYNTAX_ERROR),
-    ('(((((((((a)))))))))', 'a', SUCCEED, 'found', 'a'),
-    ('multiple words of text', 'uh-uh', FAIL),
-    ('multiple words', 'multiple words, yeah', SUCCEED, 'found', 'multiple words'),
-    ('(.*)c(.*)', 'abcde', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcde-ab-de'),
-    ('\\((.*), (.*)\\)', '(a, b)', SUCCEED, 'g2+"-"+g1', 'b-a'),
-    ('[k]', 'ab', FAIL),
-    ('a[-]?c', 'ac', SUCCEED, 'found', 'ac'),
-    ('(abc)\\1', 'abcabc', SUCCEED, 'g1', 'abc'),
-    ('([a-c]*)\\1', 'abcabc', SUCCEED, 'g1', 'abc'),
-    ('(?i)abc', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)abc', 'XBC', FAIL),
-    ('(?i)abc', 'AXC', FAIL),
-    ('(?i)abc', 'ABX', FAIL),
-    ('(?i)abc', 'XABCY', SUCCEED, 'found', 'ABC'),
-    ('(?i)abc', 'ABABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab*c', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab*bc', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab*bc', 'ABBC', SUCCEED, 'found', 'ABBC'),
-    ('(?i)ab*?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab{0,}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab+?bc', 'ABBC', SUCCEED, 'found', 'ABBC'),
-    ('(?i)ab+bc', 'ABC', FAIL),
-    ('(?i)ab+bc', 'ABQ', FAIL),
-    ('(?i)ab{1,}bc', 'ABQ', FAIL),
-    ('(?i)ab+bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab{1,}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab{1,3}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab{3,4}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab{4,5}?bc', 'ABBBBC', FAIL),
-    ('(?i)ab??bc', 'ABBC', SUCCEED, 'found', 'ABBC'),
-    ('(?i)ab??bc', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab{0,1}?bc', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab??bc', 'ABBBBC', FAIL),
-    ('(?i)ab??c', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab{0,1}?c', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)^abc$', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)^abc$', 'ABCC', FAIL),
-    ('(?i)^abc', 'ABCC', SUCCEED, 'found', 'ABC'),
-    ('(?i)^abc$', 'AABC', FAIL),
-    ('(?i)abc$', 'AABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)^', 'ABC', SUCCEED, 'found', ''),
-    ('(?i)$', 'ABC', SUCCEED, 'found', ''),
-    ('(?i)a.c', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)a.c', 'AXC', SUCCEED, 'found', 'AXC'),
-    ('(?i)a.*?c', 'AXYZC', SUCCEED, 'found', 'AXYZC'),
-    ('(?i)a.*c', 'AXYZD', FAIL),
-    ('(?i)a[bc]d', 'ABC', FAIL),
-    ('(?i)a[bc]d', 'ABD', SUCCEED, 'found', 'ABD'),
-    ('(?i)a[b-d]e', 'ABD', FAIL),
-    ('(?i)a[b-d]e', 'ACE', SUCCEED, 'found', 'ACE'),
-    ('(?i)a[b-d]', 'AAC', SUCCEED, 'found', 'AC'),
-    ('(?i)a[-b]', 'A-', SUCCEED, 'found', 'A-'),
-    ('(?i)a[b-]', 'A-', SUCCEED, 'found', 'A-'),
-    ('(?i)a[b-a]', '-', SYNTAX_ERROR),
-    ('(?i)a[]b', '-', SYNTAX_ERROR),
-    ('(?i)a[', '-', SYNTAX_ERROR),
-    ('(?i)a]', 'A]', SUCCEED, 'found', 'A]'),
-    ('(?i)a[]]b', 'A]B', SUCCEED, 'found', 'A]B'),
-    ('(?i)a[^bc]d', 'AED', SUCCEED, 'found', 'AED'),
-    ('(?i)a[^bc]d', 'ABD', FAIL),
-    ('(?i)a[^-b]c', 'ADC', SUCCEED, 'found', 'ADC'),
-    ('(?i)a[^-b]c', 'A-C', FAIL),
-    ('(?i)a[^]b]c', 'A]C', FAIL),
-    ('(?i)a[^]b]c', 'ADC', SUCCEED, 'found', 'ADC'),
-    ('(?i)ab|cd', 'ABC', SUCCEED, 'found', 'AB'),
-    ('(?i)ab|cd', 'ABCD', SUCCEED, 'found', 'AB'),
-    ('(?i)()ef', 'DEF', SUCCEED, 'found+"-"+g1', 'EF-'),
-    ('(?i)*a', '-', SYNTAX_ERROR),
-    ('(?i)(*)b', '-', SYNTAX_ERROR),
-    ('(?i)$b', 'B', FAIL),
-    ('(?i)a\\', '-', SYNTAX_ERROR),
-    ('(?i)a\\(b', 'A(B', SUCCEED, 'found+"-"+g1', 'A(B-Error'),
-    ('(?i)a\\(*b', 'AB', SUCCEED, 'found', 'AB'),
-    ('(?i)a\\(*b', 'A((B', SUCCEED, 'found', 'A((B'),
-    ('(?i)a\\\\b', 'A\\B', SUCCEED, 'found', 'A\\B'),
-    ('(?i)abc)', '-', SYNTAX_ERROR),
-    ('(?i)(abc', '-', SYNTAX_ERROR),
-    ('(?i)((a))', 'ABC', SUCCEED, 'found+"-"+g1+"-"+g2', 'A-A-A'),
-    ('(?i)(a)b(c)', 'ABC', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABC-A-C'),
-    ('(?i)a+b+c', 'AABBABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)a{1,}b{1,}c', 'AABBABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)a**', '-', SYNTAX_ERROR),
-    ('(?i)a.+?c', 'ABCABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)a.*?c', 'ABCABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)a.{0,5}?c', 'ABCABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)(a+|b)*', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
-    ('(?i)(a+|b){0,}', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
-    ('(?i)(a+|b)+', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
-    ('(?i)(a+|b){1,}', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
-    ('(?i)(a+|b)?', 'AB', SUCCEED, 'found+"-"+g1', 'A-A'),
-    ('(?i)(a+|b){0,1}', 'AB', SUCCEED, 'found+"-"+g1', 'A-A'),
-    ('(?i)(a+|b){0,1}?', 'AB', SUCCEED, 'found+"-"+g1', '-None'),
-    ('(?i))(', '-', SYNTAX_ERROR),
-    ('(?i)[^ab]*', 'CDE', SUCCEED, 'found', 'CDE'),
-    ('(?i)abc', '', FAIL),
-    ('(?i)a*', '', SUCCEED, 'found', ''),
-    ('(?i)([abc])*d', 'ABBBCD', SUCCEED, 'found+"-"+g1', 'ABBBCD-C'),
-    ('(?i)([abc])*bcd', 'ABCD', SUCCEED, 'found+"-"+g1', 'ABCD-A'),
-    ('(?i)a|b|c|d|e', 'E', SUCCEED, 'found', 'E'),
-    ('(?i)(a|b|c|d|e)f', 'EF', SUCCEED, 'found+"-"+g1', 'EF-E'),
-    ('(?i)abcd*efg', 'ABCDEFG', SUCCEED, 'found', 'ABCDEFG'),
-    ('(?i)ab*', 'XABYABBBZ', SUCCEED, 'found', 'AB'),
-    ('(?i)ab*', 'XAYABBBZ', SUCCEED, 'found', 'A'),
-    ('(?i)(ab|cd)e', 'ABCDE', SUCCEED, 'found+"-"+g1', 'CDE-CD'),
-    ('(?i)[abhgefdc]ij', 'HIJ', SUCCEED, 'found', 'HIJ'),
-    ('(?i)^(ab|cd)e', 'ABCDE', FAIL),
-    ('(?i)(abc|)ef', 'ABCDEF', SUCCEED, 'found+"-"+g1', 'EF-'),
-    ('(?i)(a|b)c*d', 'ABCD', SUCCEED, 'found+"-"+g1', 'BCD-B'),
-    ('(?i)(ab|ab*)bc', 'ABC', SUCCEED, 'found+"-"+g1', 'ABC-A'),
-    ('(?i)a([bc]*)c*', 'ABC', SUCCEED, 'found+"-"+g1', 'ABC-BC'),
-    ('(?i)a([bc]*)(c*d)', 'ABCD', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCD-BC-D'),
-    ('(?i)a([bc]+)(c*d)', 'ABCD', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCD-BC-D'),
-    ('(?i)a([bc]*)(c+d)', 'ABCD', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCD-B-CD'),
-    ('(?i)a[bcd]*dcdcde', 'ADCDCDE', SUCCEED, 'found', 'ADCDCDE'),
-    ('(?i)a[bcd]+dcdcde', 'ADCDCDE', FAIL),
-    ('(?i)(ab|a)b*c', 'ABC', SUCCEED, 'found+"-"+g1', 'ABC-AB'),
-    ('(?i)((a)(b)c)(d)', 'ABCD', SUCCEED, 'g1+"-"+g2+"-"+g3+"-"+g4', 'ABC-A-B-D'),
-    ('(?i)[a-zA-Z_][a-zA-Z0-9_]*', 'ALPHA', SUCCEED, 'found', 'ALPHA'),
-    ('(?i)^a(bc+|b[eh])g|.h$', 'ABH', SUCCEED, 'found+"-"+g1', 'BH-None'),
-    ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'EFFGZ', SUCCEED, 'found+"-"+g1+"-"+g2', 'EFFGZ-EFFGZ-None'),
-    ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'IJ', SUCCEED, 'found+"-"+g1+"-"+g2', 'IJ-IJ-J'),
-    ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'EFFG', FAIL),
-    ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'BCDD', FAIL),
-    ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'REFFGZ', SUCCEED, 'found+"-"+g1+"-"+g2', 'EFFGZ-EFFGZ-None'),
-    ('(?i)((((((((((a))))))))))', 'A', SUCCEED, 'g10', 'A'),
-    ('(?i)((((((((((a))))))))))\\10', 'AA', SUCCEED, 'found', 'AA'),
-    #('(?i)((((((((((a))))))))))\\41', 'AA', FAIL),
-    #('(?i)((((((((((a))))))))))\\41', 'A!', SUCCEED, 'found', 'A!'),
-    ('(?i)(((((((((a)))))))))', 'A', SUCCEED, 'found', 'A'),
-    ('(?i)(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))', 'A', SUCCEED, 'g1', 'A'),
-    ('(?i)(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))', 'C', SUCCEED, 'g1', 'C'),
-    ('(?i)multiple words of text', 'UH-UH', FAIL),
-    ('(?i)multiple words', 'MULTIPLE WORDS, YEAH', SUCCEED, 'found', 'MULTIPLE WORDS'),
-    ('(?i)(.*)c(.*)', 'ABCDE', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCDE-AB-DE'),
-    ('(?i)\\((.*), (.*)\\)', '(A, B)', SUCCEED, 'g2+"-"+g1', 'B-A'),
-    ('(?i)[k]', 'AB', FAIL),
-#    ('(?i)abcd', 'ABCD', SUCCEED, 'found+"-"+\\found+"-"+\\\\found', 'ABCD-$&-\\ABCD'),
-#    ('(?i)a(bc)d', 'ABCD', SUCCEED, 'g1+"-"+\\g1+"-"+\\\\g1', 'BC-$1-\\BC'),
-    ('(?i)a[-]?c', 'AC', SUCCEED, 'found', 'AC'),
-    ('(?i)(abc)\\1', 'ABCABC', SUCCEED, 'g1', 'ABC'),
-    ('(?i)([a-c]*)\\1', 'ABCABC', SUCCEED, 'g1', 'ABC'),
-    ('a(?!b).', 'abad', SUCCEED, 'found', 'ad'),
-    ('a(?=d).', 'abad', SUCCEED, 'found', 'ad'),
-    ('a(?=c|d).', 'abad', SUCCEED, 'found', 'ad'),
-    ('a(?:b|c|d)(.)', 'ace', SUCCEED, 'g1', 'e'),
-    ('a(?:b|c|d)*(.)', 'ace', SUCCEED, 'g1', 'e'),
-    ('a(?:b|c|d)+?(.)', 'ace', SUCCEED, 'g1', 'e'),
-    ('a(?:b|(c|e){1,2}?|d)+?(.)', 'ace', SUCCEED, 'g1 + g2', 'ce'),
-    ('^(.+)?B', 'AB', SUCCEED, 'g1', 'A'),
-
-    # lookbehind: split by : but not if it is escaped by -.
-    ('(?<!-):(.*?)(?<!-):', 'a:bc-:de:f', SUCCEED, 'g1', 'bc-:de' ),
-    # escaping with \ as we know it
-    ('(?<!\\\):(.*?)(?<!\\\):', 'a:bc\\:de:f', SUCCEED, 'g1', 'bc\\:de' ),
-    # terminating with ' and escaping with ? as in edifact
-    ("(?<!\\?)'(.*?)(?<!\\?)'", "a'bc?'de'f", SUCCEED, 'g1', "bc?'de" ),
-
-    # Comments using the (?#...) syntax
-
-    ('w(?# comment', 'w', SYNTAX_ERROR),
-    ('w(?# comment 1)xy(?# comment 2)z', 'wxyz', SUCCEED, 'found', 'wxyz'),
-
-    # Check odd placement of embedded pattern modifiers
-
-    # not an error under PCRE/PRE:
-    ('w(?i)', 'W', SUCCEED, 'found', 'W'),
-    # ('w(?i)', 'W', SYNTAX_ERROR),
-
-    # Comments using the x embedded pattern modifier
-
-    ("""(?x)w# comment 1
-        x y
-        # comment 2
-        z""", 'wxyz', SUCCEED, 'found', 'wxyz'),
-
-    # using the m embedded pattern modifier
-
-    ('^abc', """jkl
-abc
-xyz""", FAIL),
-    ('(?m)^abc', """jkl
-abc
-xyz""", SUCCEED, 'found', 'abc'),
-
-    ('(?m)abc$', """jkl
-xyzabc
-123""", SUCCEED, 'found', 'abc'),
-
-    # using the s embedded pattern modifier
-
-    ('a.b', 'a\nb', FAIL),
-    ('(?s)a.b', 'a\nb', SUCCEED, 'found', 'a\nb'),
-
-    # test \w, etc. both inside and outside character classes
-
-    ('\\w+', '--ab_cd0123--', SUCCEED, 'found', 'ab_cd0123'),
-    ('[\\w]+', '--ab_cd0123--', SUCCEED, 'found', 'ab_cd0123'),
-    ('\\D+', '1234abc5678', SUCCEED, 'found', 'abc'),
-    ('[\\D]+', '1234abc5678', SUCCEED, 'found', 'abc'),
-    ('[\\da-fA-F]+', '123abc', SUCCEED, 'found', '123abc'),
-    # not an error under PCRE/PRE:
-    # ('[\\d-x]', '-', SYNTAX_ERROR),
-    (r'([\s]*)([\S]*)([\s]*)', ' testing!1972', SUCCEED, 'g3+g2+g1', 'testing!1972 '),
-    (r'(\s*)(\S*)(\s*)', ' testing!1972', SUCCEED, 'g3+g2+g1', 'testing!1972 '),
-
-    (r'\xff', '\377', SUCCEED, 'found', chr(255)),
-    # new \x semantics
-    (r'\x00ff', '\377', FAIL),
-    # (r'\x00ff', '\377', SUCCEED, 'found', chr(255)),
-    (r'\t\n\v\r\f\a\g', '\t\n\v\r\f\ag', SUCCEED, 'found', '\t\n\v\r\f\ag'),
-    ('\t\n\v\r\f\a\g', '\t\n\v\r\f\ag', SUCCEED, 'found', '\t\n\v\r\f\ag'),
-    (r'\t\n\v\r\f\a', '\t\n\v\r\f\a', SUCCEED, 'found', chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)),
-    (r'[\t][\n][\v][\r][\f][\b]', '\t\n\v\r\f\b', SUCCEED, 'found', '\t\n\v\r\f\b'),
-
-    #
-    # post-1.5.2 additions
-
-    # xmllib problem
-    (r'(([a-z]+):)?([a-z]+)$', 'smil', SUCCEED, 'g1+"-"+g2+"-"+g3', 'None-None-smil'),
-    # bug 110866: reference to undefined group
-    (r'((.)\1+)', '', SYNTAX_ERROR),
-    # bug 111869: search (PRE/PCRE fails on this one, SRE doesn't)
-    (r'.*d', 'abc\nabd', SUCCEED, 'found', 'abd'),
-    # bug 112468: various expected syntax errors
-    (r'(', '', SYNTAX_ERROR),
-    (r'[\41]', '!', SUCCEED, 'found', '!'),
-    # bug 114033: nothing to repeat
-    (r'(x?)?', 'x', SUCCEED, 'found', 'x'),
-    # bug 115040: rescan if flags are modified inside pattern
-    (r' (?x)foo ', 'foo', SUCCEED, 'found', 'foo'),
-    # bug 115618: negative lookahead
-    (r'(?<!abc)(d.f)', 'abcdefdof', SUCCEED, 'found', 'dof'),
-    # bug 116251: character class bug
-    (r'[\w-]+', 'laser_beam', SUCCEED, 'found', 'laser_beam'),
-    # bug 123769+127259: non-greedy backtracking bug
-    (r'.*?\S *:', 'xx:', SUCCEED, 'found', 'xx:'),
-    (r'a[ ]*?\ (\d+).*', 'a   10', SUCCEED, 'found', 'a   10'),
-    (r'a[ ]*?\ (\d+).*', 'a    10', SUCCEED, 'found', 'a    10'),
-    # bug 127259: \Z shouldn't depend on multiline mode
-    (r'(?ms).*?x\s*\Z(.*)','xx\nx\n', SUCCEED, 'g1', ''),
-    # bug 128899: uppercase literals under the ignorecase flag
-    (r'(?i)M+', 'MMM', SUCCEED, 'found', 'MMM'),
-    (r'(?i)m+', 'MMM', SUCCEED, 'found', 'MMM'),
-    (r'(?i)[M]+', 'MMM', SUCCEED, 'found', 'MMM'),
-    (r'(?i)[m]+', 'MMM', SUCCEED, 'found', 'MMM'),
-    # bug 130748: ^* should be an error (nothing to repeat)
-    (r'^*', '', SYNTAX_ERROR),
-    # bug 133283: minimizing repeat problem
-    (r'"(?:\\"|[^"])*?"', r'"\""', SUCCEED, 'found', r'"\""'),
-    # bug 477728: minimizing repeat problem
-    (r'^.*?$', 'one\ntwo\nthree\n', FAIL),
-    # bug 483789: minimizing repeat problem
-    (r'a[^>]*?b', 'a>b', FAIL),
-    # bug 490573: minimizing repeat problem
-    (r'^a*?$', 'foo', FAIL),
-    # bug 470582: nested groups problem
-    (r'^((a)c)?(ab)$', 'ab', SUCCEED, 'g1+"-"+g2+"-"+g3', 'None-None-ab'),
-    # another minimizing repeat problem (capturing groups in assertions)
-    ('^([ab]*?)(?=(b)?)c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
-    ('^([ab]*?)(?!(b))c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
-    ('^([ab]*?)(?<!(a))c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
-]
-
-u = '\N{LATIN CAPITAL LETTER A WITH DIAERESIS}'
-tests.extend([
-    # bug 410271: \b broken under locales
-    (r'\b.\b', 'a', SUCCEED, 'found', 'a'),
-    (r'(?u)\b.\b', u, SUCCEED, 'found', u),
-    (r'(?u)\w', u, SUCCEED, 'found', u),
-])

regex/re_tests_uniq.py

@@ -1,516 +0,0 @@
-#!/usr/bin/env python3
-# -*- mode: python -*-
-
-# Re test suite and benchmark suite v1.5
-# The 3 possible outcomes for each pattern
-[SUCCEED, FAIL, SYNTAX_ERROR] = range(3)
-# Benchmark suite (needs expansion)
-#
-# The benchmark suite does not test correctness, just speed.  The
-# first element of each tuple is the regex pattern; the second is a
-# string to match it against.  The benchmarking code will embed the
-# second string inside several sizes of padding, to test how regex
-# matching performs on large strings.
-benchmarks = [
-    # test common prefix
-    ('Python|Perl', 'Perl'),    # Alternation
-    ('(Python|Perl)', 'Perl'),  # Grouped alternation
-    ('Python|Perl|Tcl', 'Perl'),        # Alternation
-    ('(Python|Perl|Tcl)', 'Perl'),      # Grouped alternation
-    ('(Python)\\1', 'PythonPython'),    # Backreference
-    ('([0a-z][a-z0-9]*,)+', 'a5,b7,c9,'), # Disable the fastmap optimization
-    ('([a-z][a-z0-9]*,)+', 'a5,b7,c9,'), # A few sets
-    ('Python', 'Python'),               # Simple text literal
-    ('.*Python', 'Python'),             # Bad text literal
-    ('.*Python.*', 'Python'),           # Worse text literal
-    ('.*(Python)', 'Python'),           # Bad text literal with grouping
-]
-# Test suite (for verifying correctness)
-# The test suite is a list of 5- or 3-tuples.  The 5 parts of a
-# complete tuple are:
-# element 0: a string containing the pattern
-#         1: the string to match against the pattern
-#         2: the expected result (SUCCEED, FAIL, SYNTAX_ERROR)
-#         3: a string that will be eval()'ed to produce a test string.
-#            This is an arbitrary Python expression; the available
-#            variables are "found" (the whole match), and "g1", "g2", ...
-#            up to "g99" contain the contents of each group, or the
-#            string 'None' if the group wasn't given a value, or the
-#            string 'Error' if the group index was out of range;
-#            also "groups", the return value of m.group() (a tuple).
-#         4: The expected result of evaluating the expression.
-#            If the two don't match, an error is reported.
-# If the regex isn't expected to work, the latter two elements can be omitted.
-tests = [
-    # Test ?P< and ?P= extensions
-    ('(?P<foo_123', '', SYNTAX_ERROR),      # Unterminated group identifier
-    ('(?P<1>a)', '', SYNTAX_ERROR),         # Begins with a digit
-    ('(?P<!>a)', '', SYNTAX_ERROR),         # Begins with an illegal char
-    ('(?P<foo!>a)', '', SYNTAX_ERROR),      # Begins with an illegal char
-    # Same tests, for the ?P= form
-    ('(?P<foo_123>a)(?P=foo_123', 'aa', SYNTAX_ERROR),
-    ('(?P<foo_123>a)(?P=1)', 'aa', SYNTAX_ERROR),
-    ('(?P<foo_123>a)(?P=!)', 'aa', SYNTAX_ERROR),
-    ('(?P<foo_123>a)(?P=foo_124', 'aa', SYNTAX_ERROR),  # Backref to undefined group
-    ('(?P<foo_123>a)', 'a', SUCCEED, 'g1', 'a'),
-    ('(?P<foo_123>a)(?P=foo_123)', 'aa', SUCCEED, 'g1', 'a'),
-    # Test octal escapes
-    ('\\1', 'a', SYNTAX_ERROR),    # Backreference
-    ('[\\1]', '\1', SUCCEED, 'found', '\1'),  # Character
-    ('\\09', chr(0) + '9', SUCCEED, 'found', chr(0) + '9'),
-    ('\\141', 'a', SUCCEED, 'found', 'a'),
-    ('(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)\\119', 'abcdefghijklk9', SUCCEED, 'found+"-"+g11', 'abcdefghijklk9-k'),
-    # Test \0 is handled everywhere
-    (r'\0', '\0', SUCCEED, 'found', '\0'),
-    (r'[\0a]', '\0', SUCCEED, 'found', '\0'),
-    (r'[a\0]', '\0', SUCCEED, 'found', '\0'),
-    (r'[^a\0]', '\0', FAIL),
-    # Test various letter escapes
-    (r'\a[\b]\f\n\r\t\v', '\a\b\f\n\r\t\v', SUCCEED, 'found', '\a\b\f\n\r\t\v'),
-    (r'[\a][\b][\f][\n][\r][\t][\v]', '\a\b\f\n\r\t\v', SUCCEED, 'found', '\a\b\f\n\r\t\v'),
-    # NOTE: not an error under PCRE/PRE:
-    # (r'\u', '', SYNTAX_ERROR),    # A Perl escape
-    (r'\c\e\g\h\i\j\k\m\o\p\q\y\z', 'ceghijkmopqyz', SUCCEED, 'found', 'ceghijkmopqyz'),
-    (r'\xff', '\377', SUCCEED, 'found', chr(255)),
-    # new \x semantics
-    (r'\x00ffffffffffffff', '\377', FAIL, 'found', chr(255)),
-    (r'\x00f', '\017', FAIL, 'found', chr(15)),
-    (r'\x00fe', '\376', FAIL, 'found', chr(254)),
-    # (r'\x00ffffffffffffff', '\377', SUCCEED, 'found', chr(255)),
-    # (r'\x00f', '\017', SUCCEED, 'found', chr(15)),
-    # (r'\x00fe', '\376', SUCCEED, 'found', chr(254)),
-    (r"^\w+=(\\[\000-\277]|[^\n\\])*", "SRC=eval.c g.c blah blah blah \\\\\n\tapes.c",
-     SUCCEED, 'found', "SRC=eval.c g.c blah blah blah \\\\"),
-    # Test that . only matches \n in DOTALL mode
-    ('a.b', 'acb', SUCCEED, 'found', 'acb'),
-    ('a.b', 'a\nb', FAIL),
-    ('a.*b', 'acc\nccb', FAIL),
-    ('a.{4,5}b', 'acc\nccb', FAIL),
-    ('a.b', 'a\rb', SUCCEED, 'found', 'a\rb'),
-    ('a.b(?s)', 'a\nb', SUCCEED, 'found', 'a\nb'),
-    ('a.*(?s)b', 'acc\nccb', SUCCEED, 'found', 'acc\nccb'),
-    ('(?s)a.{4,5}b', 'acc\nccb', SUCCEED, 'found', 'acc\nccb'),
-    ('(?s)a.b', 'a\nb', SUCCEED, 'found', 'a\nb'),
-    (')', '', SYNTAX_ERROR),           # Unmatched right bracket
-    ('', '', SUCCEED, 'found', ''),    # Empty pattern
-    ('abc', 'abc', SUCCEED, 'found', 'abc'),
-    ('abc', 'xbc', FAIL),
-    ('abc', 'axc', FAIL),
-    ('abc', 'abx', FAIL),
-    ('abc', 'xabcy', SUCCEED, 'found', 'abc'),
-    ('abc', 'ababc', SUCCEED, 'found', 'abc'),
-    ('ab*c', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab*bc', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab*bc', 'abbc', SUCCEED, 'found', 'abbc'),
-    ('ab*bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab+bc', 'abbc', SUCCEED, 'found', 'abbc'),
-    ('ab+bc', 'abc', FAIL),
-    ('ab+bc', 'abq', FAIL),
-    ('ab+bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab?bc', 'abbc', SUCCEED, 'found', 'abbc'),
-    ('ab?bc', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab?bc', 'abbbbc', FAIL),
-    ('ab?c', 'abc', SUCCEED, 'found', 'abc'),
-    ('^abc$', 'abc', SUCCEED, 'found', 'abc'),
-    ('^abc$', 'abcc', FAIL),
-    ('^abc', 'abcc', SUCCEED, 'found', 'abc'),
-    ('^abc$', 'aabc', FAIL),
-    ('abc$', 'aabc', SUCCEED, 'found', 'abc'),
-    ('^', 'abc', SUCCEED, 'found+"-"', '-'),
-    ('$', 'abc', SUCCEED, 'found+"-"', '-'),
-    ('a.c', 'abc', SUCCEED, 'found', 'abc'),
-    ('a.c', 'axc', SUCCEED, 'found', 'axc'),
-    ('a.*c', 'axyzc', SUCCEED, 'found', 'axyzc'),
-    ('a.*c', 'axyzd', FAIL),
-    ('a[bc]d', 'abc', FAIL),
-    ('a[bc]d', 'abd', SUCCEED, 'found', 'abd'),
-    ('a[b-d]e', 'abd', FAIL),
-    ('a[b-d]e', 'ace', SUCCEED, 'found', 'ace'),
-    ('a[b-d]', 'aac', SUCCEED, 'found', 'ac'),
-    ('a[-b]', 'a-', SUCCEED, 'found', 'a-'),
-    ('a[\\-b]', 'a-', SUCCEED, 'found', 'a-'),
-    # ('a[b-]', 'a-', SYNTAX_ERROR),
-    ('a[]b', '-', SYNTAX_ERROR),
-    ('a[', '-', SYNTAX_ERROR),
-    ('a\\', '-', SYNTAX_ERROR),
-    ('abc)', '-', SYNTAX_ERROR),
-    ('(abc', '-', SYNTAX_ERROR),
-    ('a]', 'a]', SUCCEED, 'found', 'a]'),
-    ('a[]]b', 'a]b', SUCCEED, 'found', 'a]b'),
-    ('a[\]]b', 'a]b', SUCCEED, 'found', 'a]b'),
-    ('a[^bc]d', 'aed', SUCCEED, 'found', 'aed'),
-    ('a[^bc]d', 'abd', FAIL),
-    ('a[^-b]c', 'adc', SUCCEED, 'found', 'adc'),
-    ('a[^-b]c', 'a-c', FAIL),
-    ('a[^]b]c', 'a]c', FAIL),
-    ('a[^]b]c', 'adc', SUCCEED, 'found', 'adc'),
-    ('\\ba\\b', 'a-', SUCCEED, '"-"', '-'),
-    ('\\ba\\b', '-a', SUCCEED, '"-"', '-'),
-    ('\\ba\\b', '-a-', SUCCEED, '"-"', '-'),
-    ('\\by\\b', 'xy', FAIL),
-    ('\\by\\b', 'yz', FAIL),
-    ('\\by\\b', 'xyz', FAIL),
-    ('x\\b', 'xyz', FAIL),
-    ('x\\B', 'xyz', SUCCEED, '"-"', '-'),
-    ('\\Bz', 'xyz', SUCCEED, '"-"', '-'),
-    ('z\\B', 'xyz', FAIL),
-    ('\\Bx', 'xyz', FAIL),
-    ('\\Ba\\B', 'a-', FAIL, '"-"', '-'),
-    ('\\Ba\\B', '-a', FAIL, '"-"', '-'),
-    ('\\Ba\\B', '-a-', FAIL, '"-"', '-'),
-    ('\\By\\B', 'xy', FAIL),
-    ('\\By\\B', 'yz', FAIL),
-    ('\\By\\b', 'xy', SUCCEED, '"-"', '-'),
-    ('\\by\\B', 'yz', SUCCEED, '"-"', '-'),
-    ('\\By\\B', 'xyz', SUCCEED, '"-"', '-'),
-    ('ab|cd', 'abc', SUCCEED, 'found', 'ab'),
-    ('ab|cd', 'abcd', SUCCEED, 'found', 'ab'),
-    ('()ef', 'def', SUCCEED, 'found+"-"+g1', 'ef-'),
-    ('$b', 'b', FAIL),
-    ('a\\(b', 'a(b', SUCCEED, 'found+"-"+g1', 'a(b-Error'),
-    ('a\\(*b', 'ab', SUCCEED, 'found', 'ab'),
-    ('a\\(*b', 'a((b', SUCCEED, 'found', 'a((b'),
-    ('a\\\\b', 'a\\b', SUCCEED, 'found', 'a\\b'),
-    ('((a))', 'abc', SUCCEED, 'found+"-"+g1+"-"+g2', 'a-a-a'),
-    ('(a)b(c)', 'abc', SUCCEED, 'found+"-"+g1+"-"+g2', 'abc-a-c'),
-    ('a+b+c', 'aabbabc', SUCCEED, 'found', 'abc'),
-    ('(a+|b)*', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
-    ('(a+|b)+', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
-    ('(a+|b)?', 'ab', SUCCEED, 'found+"-"+g1', 'a-a'),
-    (')(', '-', SYNTAX_ERROR),
-    ('[^ab]*', 'cde', SUCCEED, 'found', 'cde'),
-    ('abc', '', FAIL),
-    ('a*', '', SUCCEED, 'found', ''),
-    ('a|b|c|d|e', 'e', SUCCEED, 'found', 'e'),
-    ('(a|b|c|d|e)f', 'ef', SUCCEED, 'found+"-"+g1', 'ef-e'),
-    ('abcd*efg', 'abcdefg', SUCCEED, 'found', 'abcdefg'),
-    ('ab*', 'xabyabbbz', SUCCEED, 'found', 'ab'),
-    ('ab*', 'xayabbbz', SUCCEED, 'found', 'a'),
-    ('(ab|cd)e', 'abcde', SUCCEED, 'found+"-"+g1', 'cde-cd'),
-    ('[abhgefdc]ij', 'hij', SUCCEED, 'found', 'hij'),
-    ('^(ab|cd)e', 'abcde', FAIL, 'xg1y', 'xy'),
-    ('(abc|)ef', 'abcdef', SUCCEED, 'found+"-"+g1', 'ef-'),
-    ('(a|b)c*d', 'abcd', SUCCEED, 'found+"-"+g1', 'bcd-b'),
-    ('(ab|ab*)bc', 'abc', SUCCEED, 'found+"-"+g1', 'abc-a'),
-    ('a([bc]*)c*', 'abc', SUCCEED, 'found+"-"+g1', 'abc-bc'),
-    ('a([bc]*)(c*d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
-    ('a([bc]+)(c*d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-bc-d'),
-    ('a([bc]*)(c+d)', 'abcd', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcd-b-cd'),
-    ('a[bcd]*dcdcde', 'adcdcde', SUCCEED, 'found', 'adcdcde'),
-    ('a[bcd]+dcdcde', 'adcdcde', FAIL),
-    ('(ab|a)b*c', 'abc', SUCCEED, 'found+"-"+g1', 'abc-ab'),
-    ('((a)(b)c)(d)', 'abcd', SUCCEED, 'g1+"-"+g2+"-"+g3+"-"+g4', 'abc-a-b-d'),
-    ('[a-zA-Z_][a-zA-Z0-9_]*', 'alpha', SUCCEED, 'found', 'alpha'),
-    ('^a(bc+|b[eh])g|.h$', 'abh', SUCCEED, 'found+"-"+g1', 'bh-None'),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'effgz', SUCCEED, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'ij', SUCCEED, 'found+"-"+g1+"-"+g2', 'ij-ij-j'),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'effg', FAIL),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'bcdd', FAIL),
-    ('(bc+d$|ef*g.|h?i(j|k))', 'reffgz', SUCCEED, 'found+"-"+g1+"-"+g2', 'effgz-effgz-None'),
-    ('(((((((((a)))))))))', 'a', SUCCEED, 'found', 'a'),
-    ('multiple words of text', 'uh-uh', FAIL),
-    ('multiple words', 'multiple words, yeah', SUCCEED, 'found', 'multiple words'),
-    ('(.*)c(.*)', 'abcde', SUCCEED, 'found+"-"+g1+"-"+g2', 'abcde-ab-de'),
-    ('\\((.*), (.*)\\)', '(a, b)', SUCCEED, 'g2+"-"+g1', 'b-a'),
-    ('[k]', 'ab', FAIL),
-    ('a[-]?c', 'ac', SUCCEED, 'found', 'ac'),
-    ('(abc)\\1', 'abcabc', SUCCEED, 'g1', 'abc'),
-    ('([a-c]*)\\1', 'abcabc', SUCCEED, 'g1', 'abc'),
-    ('^(.+)?B', 'AB', SUCCEED, 'g1', 'A'),
-    ('(a+).\\1$', 'aaaaa', SUCCEED, 'found+"-"+g1', 'aaaaa-aa'),
-    ('^(a+).\\1$', 'aaaa', FAIL),
-    ('(abc)\\1', 'abcabc', SUCCEED, 'found+"-"+g1', 'abcabc-abc'),
-    ('([a-c]+)\\1', 'abcabc', SUCCEED, 'found+"-"+g1', 'abcabc-abc'),
-    ('(a)\\1', 'aa', SUCCEED, 'found+"-"+g1', 'aa-a'),
-    ('(a+)\\1', 'aa', SUCCEED, 'found+"-"+g1', 'aa-a'),
-    ('(a+)+\\1', 'aa', SUCCEED, 'found+"-"+g1', 'aa-a'),
-    ('(a).+\\1', 'aba', SUCCEED, 'found+"-"+g1', 'aba-a'),
-    ('(a)ba*\\1', 'aba', SUCCEED, 'found+"-"+g1', 'aba-a'),
-    ('(aa|a)a\\1$', 'aaa', SUCCEED, 'found+"-"+g1', 'aaa-a'),
-    ('(a|aa)a\\1$', 'aaa', SUCCEED, 'found+"-"+g1', 'aaa-a'),
-    ('(a+)a\\1$', 'aaa', SUCCEED, 'found+"-"+g1', 'aaa-a'),
-    ('([abc]*)\\1', 'abcabc', SUCCEED, 'found+"-"+g1', 'abcabc-abc'),
-    ('(a)(b)c|ab', 'ab', SUCCEED, 'found+"-"+g1+"-"+g2', 'ab-None-None'),
-    ('(a)+x', 'aaax', SUCCEED, 'found+"-"+g1', 'aaax-a'),
-    ('([ac])+x', 'aacx', SUCCEED, 'found+"-"+g1', 'aacx-c'),
-    ('([^/]*/)*sub1/', 'd:msgs/tdir/sub1/trial/away.cpp', SUCCEED, 'found+"-"+g1', 'd:msgs/tdir/sub1/-tdir/'),
-    ('([^.]*)\\.([^:]*):[T ]+(.*)', 'track1.title:TBlah blah blah', SUCCEED, 'found+"-"+g1+"-"+g2+"-"+g3', 'track1.title:TBlah blah blah-track1-title-Blah blah blah'),
-    ('([^N]*N)+', 'abNNxyzN', SUCCEED, 'found+"-"+g1', 'abNNxyzN-xyzN'),
-    ('([^N]*N)+', 'abNNxyz', SUCCEED, 'found+"-"+g1', 'abNN-N'),
-    ('([abc]*)x', 'abcx', SUCCEED, 'found+"-"+g1', 'abcx-abc'),
-    ('([abc]*)x', 'abc', FAIL),
-    ('([xyz]*)x', 'abcx', SUCCEED, 'found+"-"+g1', 'x-'),
-    ('(a)+b|aac', 'aac', SUCCEED, 'found+"-"+g1', 'aac-None'),
-    # Test symbolic groups
-    ('(?P<i d>aaa)a', 'aaaa', SYNTAX_ERROR),
-    ('(?P<id>aaa)a', 'aaaa', SUCCEED, 'found+"-"+id', 'aaaa-aaa'),
-    ('(?P<id>aa)(?P=id)', 'aaaa', SUCCEED, 'found+"-"+id', 'aaaa-aa'),
-    ('(?P<id>aa)(?P=xd)', 'aaaa', SYNTAX_ERROR),
-    # Test octal escapes/memory references
-    ('\\1', 'a', SYNTAX_ERROR),
-    # All tests from Perl
-    ('ab{0,}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab{1,}bc', 'abq', FAIL),
-    ('ab{1,}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab{1,3}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab{3,4}bc', 'abbbbc', SUCCEED, 'found', 'abbbbc'),
-    ('ab{4,5}bc', 'abbbbc', FAIL),
-    ('ab{0,1}bc', 'abc', SUCCEED, 'found', 'abc'),
-    ('ab{0,1}c', 'abc', SUCCEED, 'found', 'abc'),
-    ('^', 'abc', SUCCEED, 'found', ''),
-    ('$', 'abc', SUCCEED, 'found', ''),
-    ('a[b-]', 'a-', SUCCEED, 'found', 'a-'),
-    ('a[b-a]', '-', SYNTAX_ERROR),
-    ('*a', '-', SYNTAX_ERROR),
-    ('(*)b', '-', SYNTAX_ERROR),
-    ('a{1,}b{1,}c', 'aabbabc', SUCCEED, 'found', 'abc'),
-    ('a**', '-', SYNTAX_ERROR),
-    ('a.+?c', 'abcabc', SUCCEED, 'found', 'abc'),
-    ('(a+|b){0,}', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
-    ('(a+|b){1,}', 'ab', SUCCEED, 'found+"-"+g1', 'ab-b'),
-    ('(a+|b){0,1}', 'ab', SUCCEED, 'found+"-"+g1', 'a-a'),
-    ('([abc])*d', 'abbbcd', SUCCEED, 'found+"-"+g1', 'abbbcd-c'),
-    ('([abc])*bcd', 'abcd', SUCCEED, 'found+"-"+g1', 'abcd-a'),
-    ('^(ab|cd)e', 'abcde', FAIL),
-    ('((((((((((a))))))))))', 'a', SUCCEED, 'g10', 'a'),
-    ('((((((((((a))))))))))\\10', 'aa', SUCCEED, 'found', 'aa'),
-# Python does not have the same rules for \\41 so this is a syntax error
-#    ('((((((((((a))))))))))\\41', 'aa', FAIL),
-#    ('((((((((((a))))))))))\\41', 'a!', SUCCEED, 'found', 'a!'),
-    ('((((((((((a))))))))))\\41', '', SYNTAX_ERROR),
-    ('(?i)((((((((((a))))))))))\\41', '', SYNTAX_ERROR),
-    ('(?i)abc', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)abc', 'XBC', FAIL),
-    ('(?i)abc', 'AXC', FAIL),
-    ('(?i)abc', 'ABX', FAIL),
-    ('(?i)abc', 'XABCY', SUCCEED, 'found', 'ABC'),
-    ('(?i)abc', 'ABABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab*c', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab*bc', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab*bc', 'ABBC', SUCCEED, 'found', 'ABBC'),
-    ('(?i)ab*?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab{0,}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab+?bc', 'ABBC', SUCCEED, 'found', 'ABBC'),
-    ('(?i)ab+bc', 'ABC', FAIL),
-    ('(?i)ab+bc', 'ABQ', FAIL),
-    ('(?i)ab{1,}bc', 'ABQ', FAIL),
-    ('(?i)ab+bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab{1,}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab{1,3}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab{3,4}?bc', 'ABBBBC', SUCCEED, 'found', 'ABBBBC'),
-    ('(?i)ab{4,5}?bc', 'ABBBBC', FAIL),
-    ('(?i)ab??bc', 'ABBC', SUCCEED, 'found', 'ABBC'),
-    ('(?i)ab??bc', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab{0,1}?bc', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab??bc', 'ABBBBC', FAIL),
-    ('(?i)ab??c', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)ab{0,1}?c', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)^abc$', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)^abc$', 'ABCC', FAIL),
-    ('(?i)^abc', 'ABCC', SUCCEED, 'found', 'ABC'),
-    ('(?i)^abc$', 'AABC', FAIL),
-    ('(?i)abc$', 'AABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)^', 'ABC', SUCCEED, 'found', ''),
-    ('(?i)$', 'ABC', SUCCEED, 'found', ''),
-    ('(?i)a.c', 'ABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)a.c', 'AXC', SUCCEED, 'found', 'AXC'),
-    ('(?i)a.*?c', 'AXYZC', SUCCEED, 'found', 'AXYZC'),
-    ('(?i)a.*c', 'AXYZD', FAIL),
-    ('(?i)a[bc]d', 'ABC', FAIL),
-    ('(?i)a[bc]d', 'ABD', SUCCEED, 'found', 'ABD'),
-    ('(?i)a[b-d]e', 'ABD', FAIL),
-    ('(?i)a[b-d]e', 'ACE', SUCCEED, 'found', 'ACE'),
-    ('(?i)a[b-d]', 'AAC', SUCCEED, 'found', 'AC'),
-    ('(?i)a[-b]', 'A-', SUCCEED, 'found', 'A-'),
-    ('(?i)a[b-]', 'A-', SUCCEED, 'found', 'A-'),
-    ('(?i)a[b-a]', '-', SYNTAX_ERROR),
-    ('(?i)a[]b', '-', SYNTAX_ERROR),
-    ('(?i)a[', '-', SYNTAX_ERROR),
-    ('(?i)a]', 'A]', SUCCEED, 'found', 'A]'),
-    ('(?i)a[]]b', 'A]B', SUCCEED, 'found', 'A]B'),
-    ('(?i)a[^bc]d', 'AED', SUCCEED, 'found', 'AED'),
-    ('(?i)a[^bc]d', 'ABD', FAIL),
-    ('(?i)a[^-b]c', 'ADC', SUCCEED, 'found', 'ADC'),
-    ('(?i)a[^-b]c', 'A-C', FAIL),
-    ('(?i)a[^]b]c', 'A]C', FAIL),
-    ('(?i)a[^]b]c', 'ADC', SUCCEED, 'found', 'ADC'),
-    ('(?i)ab|cd', 'ABC', SUCCEED, 'found', 'AB'),
-    ('(?i)ab|cd', 'ABCD', SUCCEED, 'found', 'AB'),
-    ('(?i)()ef', 'DEF', SUCCEED, 'found+"-"+g1', 'EF-'),
-    ('(?i)*a', '-', SYNTAX_ERROR),
-    ('(?i)(*)b', '-', SYNTAX_ERROR),
-    ('(?i)$b', 'B', FAIL),
-    ('(?i)a\\', '-', SYNTAX_ERROR),
-    ('(?i)a\\(b', 'A(B', SUCCEED, 'found+"-"+g1', 'A(B-Error'),
-    ('(?i)a\\(*b', 'AB', SUCCEED, 'found', 'AB'),
-    ('(?i)a\\(*b', 'A((B', SUCCEED, 'found', 'A((B'),
-    ('(?i)a\\\\b', 'A\\B', SUCCEED, 'found', 'A\\B'),
-    ('(?i)abc)', '-', SYNTAX_ERROR),
-    ('(?i)(abc', '-', SYNTAX_ERROR),
-    ('(?i)((a))', 'ABC', SUCCEED, 'found+"-"+g1+"-"+g2', 'A-A-A'),
-    ('(?i)(a)b(c)', 'ABC', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABC-A-C'),
-    ('(?i)a+b+c', 'AABBABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)a{1,}b{1,}c', 'AABBABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)a**', '-', SYNTAX_ERROR),
-    ('(?i)a.+?c', 'ABCABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)a.*?c', 'ABCABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)a.{0,5}?c', 'ABCABC', SUCCEED, 'found', 'ABC'),
-    ('(?i)(a+|b)*', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
-    ('(?i)(a+|b){0,}', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
-    ('(?i)(a+|b)+', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
-    ('(?i)(a+|b){1,}', 'AB', SUCCEED, 'found+"-"+g1', 'AB-B'),
-    ('(?i)(a+|b)?', 'AB', SUCCEED, 'found+"-"+g1', 'A-A'),
-    ('(?i)(a+|b){0,1}', 'AB', SUCCEED, 'found+"-"+g1', 'A-A'),
-    ('(?i)(a+|b){0,1}?', 'AB', SUCCEED, 'found+"-"+g1', '-None'),
-    ('(?i))(', '-', SYNTAX_ERROR),
-    ('(?i)[^ab]*', 'CDE', SUCCEED, 'found', 'CDE'),
-    ('(?i)abc', '', FAIL),
-    ('(?i)a*', '', SUCCEED, 'found', ''),
-    ('(?i)([abc])*d', 'ABBBCD', SUCCEED, 'found+"-"+g1', 'ABBBCD-C'),
-    ('(?i)([abc])*bcd', 'ABCD', SUCCEED, 'found+"-"+g1', 'ABCD-A'),
-    ('(?i)a|b|c|d|e', 'E', SUCCEED, 'found', 'E'),
-    ('(?i)(a|b|c|d|e)f', 'EF', SUCCEED, 'found+"-"+g1', 'EF-E'),
-    ('(?i)abcd*efg', 'ABCDEFG', SUCCEED, 'found', 'ABCDEFG'),
-    ('(?i)ab*', 'XABYABBBZ', SUCCEED, 'found', 'AB'),
-    ('(?i)ab*', 'XAYABBBZ', SUCCEED, 'found', 'A'),
-    ('(?i)(ab|cd)e', 'ABCDE', SUCCEED, 'found+"-"+g1', 'CDE-CD'),
-    ('(?i)[abhgefdc]ij', 'HIJ', SUCCEED, 'found', 'HIJ'),
-    ('(?i)^(ab|cd)e', 'ABCDE', FAIL),
-    ('(?i)(abc|)ef', 'ABCDEF', SUCCEED, 'found+"-"+g1', 'EF-'),
-    ('(?i)(a|b)c*d', 'ABCD', SUCCEED, 'found+"-"+g1', 'BCD-B'),
-    ('(?i)(ab|ab*)bc', 'ABC', SUCCEED, 'found+"-"+g1', 'ABC-A'),
-    ('(?i)a([bc]*)c*', 'ABC', SUCCEED, 'found+"-"+g1', 'ABC-BC'),
-    ('(?i)a([bc]*)(c*d)', 'ABCD', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCD-BC-D'),
-    ('(?i)a([bc]+)(c*d)', 'ABCD', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCD-BC-D'),
-    ('(?i)a([bc]*)(c+d)', 'ABCD', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCD-B-CD'),
-    ('(?i)a[bcd]*dcdcde', 'ADCDCDE', SUCCEED, 'found', 'ADCDCDE'),
-    ('(?i)a[bcd]+dcdcde', 'ADCDCDE', FAIL),
-    ('(?i)(ab|a)b*c', 'ABC', SUCCEED, 'found+"-"+g1', 'ABC-AB'),
-    ('(?i)((a)(b)c)(d)', 'ABCD', SUCCEED, 'g1+"-"+g2+"-"+g3+"-"+g4', 'ABC-A-B-D'),
-    ('(?i)[a-zA-Z_][a-zA-Z0-9_]*', 'ALPHA', SUCCEED, 'found', 'ALPHA'),
-    ('(?i)^a(bc+|b[eh])g|.h$', 'ABH', SUCCEED, 'found+"-"+g1', 'BH-None'),
-    ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'EFFGZ', SUCCEED, 'found+"-"+g1+"-"+g2', 'EFFGZ-EFFGZ-None'),
-    ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'IJ', SUCCEED, 'found+"-"+g1+"-"+g2', 'IJ-IJ-J'),
-    ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'EFFG', FAIL),
-    ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'BCDD', FAIL),
-    ('(?i)(bc+d$|ef*g.|h?i(j|k))', 'REFFGZ', SUCCEED, 'found+"-"+g1+"-"+g2', 'EFFGZ-EFFGZ-None'),
-    ('(?i)((((((((((a))))))))))', 'A', SUCCEED, 'g10', 'A'),
-    ('(?i)((((((((((a))))))))))\\10', 'AA', SUCCEED, 'found', 'AA'),
-    #('(?i)((((((((((a))))))))))\\41', 'AA', FAIL),
-    #('(?i)((((((((((a))))))))))\\41', 'A!', SUCCEED, 'found', 'A!'),
-    ('(?i)(((((((((a)))))))))', 'A', SUCCEED, 'found', 'A'),
-    ('(?i)(?:(?:(?:(?:(?:(?:(?:(?:(?:(a))))))))))', 'A', SUCCEED, 'g1', 'A'),
-    ('(?i)(?:(?:(?:(?:(?:(?:(?:(?:(?:(a|b|c))))))))))', 'C', SUCCEED, 'g1', 'C'),
-    ('(?i)multiple words of text', 'UH-UH', FAIL),
-    ('(?i)multiple words', 'MULTIPLE WORDS, YEAH', SUCCEED, 'found', 'MULTIPLE WORDS'),
-    ('(?i)(.*)c(.*)', 'ABCDE', SUCCEED, 'found+"-"+g1+"-"+g2', 'ABCDE-AB-DE'),
-    ('(?i)\\((.*), (.*)\\)', '(A, B)', SUCCEED, 'g2+"-"+g1', 'B-A'),
-    ('(?i)[k]', 'AB', FAIL),
-#    ('(?i)abcd', 'ABCD', SUCCEED, 'found+"-"+\\found+"-"+\\\\found', 'ABCD-$&-\\ABCD'),
-#    ('(?i)a(bc)d', 'ABCD', SUCCEED, 'g1+"-"+\\g1+"-"+\\\\g1', 'BC-$1-\\BC'),
-    ('(?i)a[-]?c', 'AC', SUCCEED, 'found', 'AC'),
-    ('(?i)(abc)\\1', 'ABCABC', SUCCEED, 'g1', 'ABC'),
-    ('(?i)([a-c]*)\\1', 'ABCABC', SUCCEED, 'g1', 'ABC'),
-    ('a(?!b).', 'abad', SUCCEED, 'found', 'ad'),
-    ('a(?=d).', 'abad', SUCCEED, 'found', 'ad'),
-    ('a(?=c|d).', 'abad', SUCCEED, 'found', 'ad'),
-    ('a(?:b|c|d)(.)', 'ace', SUCCEED, 'g1', 'e'),
-    ('a(?:b|c|d)*(.)', 'ace', SUCCEED, 'g1', 'e'),
-    ('a(?:b|c|d)+?(.)', 'ace', SUCCEED, 'g1', 'e'),
-    ('a(?:b|(c|e){1,2}?|d)+?(.)', 'ace', SUCCEED, 'g1 + g2', 'ce'),
-    # lookbehind: split by : but not if it is escaped by -.
-    ('(?<!-):(.*?)(?<!-):', 'a:bc-:de:f', SUCCEED, 'g1', 'bc-:de' ),
-    # escaping with \ as we know it
-    ('(?<!\\\):(.*?)(?<!\\\):', 'a:bc\\:de:f', SUCCEED, 'g1', 'bc\\:de' ),
-    # terminating with ' and escaping with ? as in edifact
-    ("(?<!\\?)'(.*?)(?<!\\?)'", "a'bc?'de'f", SUCCEED, 'g1', "bc?'de" ),
-    # Comments using the (?#...) syntax
-    ('w(?# comment', 'w', SYNTAX_ERROR),
-    ('w(?# comment 1)xy(?# comment 2)z', 'wxyz', SUCCEED, 'found', 'wxyz'),
-    # Check odd placement of embedded pattern modifiers
-    # not an error under PCRE/PRE:
-    ('w(?i)', 'W', SUCCEED, 'found', 'W'),
-    # ('w(?i)', 'W', SYNTAX_ERROR),
-    # Comments using the x embedded pattern modifier
-    ("""(?x)w# comment 1
-        x y
-        # comment 2
-        z""", 'wxyz', SUCCEED, 'found', 'wxyz'),
-    # using the m embedded pattern modifier
-    ('^abc', """jkl
-abc
-xyz""", FAIL),
-    ('(?m)^abc', """jkl
-xyz""", SUCCEED, 'found', 'abc'),
-    ('(?m)abc$', """jkl
-xyzabc
-123""", SUCCEED, 'found', 'abc'),
-    # using the s embedded pattern modifier
-    # test \w, etc. both inside and outside character classes
-    ('\\w+', '--ab_cd0123--', SUCCEED, 'found', 'ab_cd0123'),
-    ('[\\w]+', '--ab_cd0123--', SUCCEED, 'found', 'ab_cd0123'),
-    ('\\D+', '1234abc5678', SUCCEED, 'found', 'abc'),
-    ('[\\D]+', '1234abc5678', SUCCEED, 'found', 'abc'),
-    ('[\\da-fA-F]+', '123abc', SUCCEED, 'found', '123abc'),
-    # ('[\\d-x]', '-', SYNTAX_ERROR),
-    (r'([\s]*)([\S]*)([\s]*)', ' testing!1972', SUCCEED, 'g3+g2+g1', 'testing!1972 '),
-    (r'(\s*)(\S*)(\s*)', ' testing!1972', SUCCEED, 'g3+g2+g1', 'testing!1972 '),
-    (r'\x00ff', '\377', FAIL),
-    # (r'\x00ff', '\377', SUCCEED, 'found', chr(255)),
-    (r'\t\n\v\r\f\a\g', '\t\n\v\r\f\ag', SUCCEED, 'found', '\t\n\v\r\f\ag'),
-    ('\t\n\v\r\f\a\g', '\t\n\v\r\f\ag', SUCCEED, 'found', '\t\n\v\r\f\ag'),
-    (r'\t\n\v\r\f\a', '\t\n\v\r\f\a', SUCCEED, 'found', chr(9)+chr(10)+chr(11)+chr(13)+chr(12)+chr(7)),
-    (r'[\t][\n][\v][\r][\f][\b]', '\t\n\v\r\f\b', SUCCEED, 'found', '\t\n\v\r\f\b'),
-    #
-    # post-1.5.2 additions
-    # xmllib problem
-    (r'(([a-z]+):)?([a-z]+)$', 'smil', SUCCEED, 'g1+"-"+g2+"-"+g3', 'None-None-smil'),
-    # bug 110866: reference to undefined group
-    (r'((.)\1+)', '', SYNTAX_ERROR),
-    # bug 111869: search (PRE/PCRE fails on this one, SRE doesn't)
-    (r'.*d', 'abc\nabd', SUCCEED, 'found', 'abd'),
-    # bug 112468: various expected syntax errors
-    (r'(', '', SYNTAX_ERROR),
-    (r'[\41]', '!', SUCCEED, 'found', '!'),
-    # bug 114033: nothing to repeat
-    (r'(x?)?', 'x', SUCCEED, 'found', 'x'),
-    # bug 115040: rescan if flags are modified inside pattern
-    (r' (?x)foo ', 'foo', SUCCEED, 'found', 'foo'),
-    # bug 115618: negative lookahead
-    (r'(?<!abc)(d.f)', 'abcdefdof', SUCCEED, 'found', 'dof'),
-    # bug 116251: character class bug
-    (r'[\w-]+', 'laser_beam', SUCCEED, 'found', 'laser_beam'),
-    # bug 123769+127259: non-greedy backtracking bug
-    (r'.*?\S *:', 'xx:', SUCCEED, 'found', 'xx:'),
-    (r'a[ ]*?\ (\d+).*', 'a   10', SUCCEED, 'found', 'a   10'),
-    (r'a[ ]*?\ (\d+).*', 'a    10', SUCCEED, 'found', 'a    10'),
-    # bug 127259: \Z shouldn't depend on multiline mode
-    (r'(?ms).*?x\s*\Z(.*)','xx\nx\n', SUCCEED, 'g1', ''),
-    # bug 128899: uppercase literals under the ignorecase flag
-    (r'(?i)M+', 'MMM', SUCCEED, 'found', 'MMM'),
-    (r'(?i)m+', 'MMM', SUCCEED, 'found', 'MMM'),
-    (r'(?i)[M]+', 'MMM', SUCCEED, 'found', 'MMM'),
-    (r'(?i)[m]+', 'MMM', SUCCEED, 'found', 'MMM'),
-    # bug 130748: ^* should be an error (nothing to repeat)
-    (r'^*', '', SYNTAX_ERROR),
-    # bug 133283: minimizing repeat problem
-    (r'"(?:\\"|[^"])*?"', r'"\""', SUCCEED, 'found', r'"\""'),
-    # bug 477728: minimizing repeat problem
-    (r'^.*?$', 'one\ntwo\nthree\n', FAIL),
-    # bug 483789: minimizing repeat problem
-    (r'a[^>]*?b', 'a>b', FAIL),
-    # bug 490573: minimizing repeat problem
-    (r'^a*?$', 'foo', FAIL),
-    # bug 470582: nested groups problem
-    (r'^((a)c)?(ab)$', 'ab', SUCCEED, 'g1+"-"+g2+"-"+g3', 'None-None-ab'),
-    # another minimizing repeat problem (capturing groups in assertions)
-    ('^([ab]*?)(?=(b)?)c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
-    ('^([ab]*?)(?!(b))c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
-    ('^([ab]*?)(?<!(a))c', 'abc', SUCCEED, 'g1+"-"+g2', 'ab-None'),
-u = '\N{LATIN CAPITAL LETTER A WITH DIAERESIS}'
-tests.extend([
-    # bug 410271: \b broken under locales
-    (r'\b.\b', 'a', SUCCEED, 'found', 'a'),
-    (r'(?u)\b.\b', u, SUCCEED, 'found', u),
-    (r'(?u)\w', u, SUCCEED, 'found', u),
-])

sliceQueue.go

@@ -1,11 +1,11 @@
-package regex
+package main
 
 import "errors"
 
 // Helper functions for slices, to make them behave more like stacks
 func peek[T any](s []T) (T, error) {
 	if len(s) < 1 {
-		return *new(T), errors.New("stack empty")
+		return *new(T), errors.New("Stack empty")
 	}
 	return s[len(s)-1], nil
 }
@@ -20,7 +20,7 @@ func mustPop[T any](sp *[]T) T {
 
 func pop[T any](sp *[]T) (T, error) {
 	if len(*sp) < 1 {
-		return *new(T), errors.New("stack empty")
+		return *new(T), errors.New("Stack empty")
 	}
 	to_return := (*sp)[len(*sp)-1]
 	*sp = (*sp)[:len(*sp)-1]

stateContents.go

@@ -1,4 +1,4 @@
-package regex
+package main
 
 type stateContents []int // Represents the contents of the current state - character classes can have multiple contents, which is why it is represented as a slice