Updated README

Reviewed-on: #4

Makefile

@@ -8,6 +8,6 @@ vet: fmt
 buildLib: vet
 	go build -gcflags="all=-N -l" ./...
 buildCmd: buildLib
-	go build -C cmd/ -gcflags="all=-N -l" -o re ./...
+	go build -C kg/ -gcflags="all=-N -l" -o kg ./...
 test: buildCmd
 	go test -v ./...

README.md

@@ -0,0 +1,21 @@
+## Kleingrep
+
+Kleingrep is a regular expression engine, providing a library and command-line tool written in Go.
+
+It aims to provide a more featureful engine, compared to the one in Go's
+[regexp](https://pkg.go.dev/regexp), while retaining some semblance of efficiency.
+
+The engine does __not__ use backtracking, relying on the NFA-based method described in
+[Russ Cox's articles](https://swtch.com/~rsc/regexp). As such, it is immune to catastrophic backtracking.
+
+It also includes features not present in regexp, such as lookarounds and backreferences.
+
+### Syntax
+
+The syntax is, for the most part, a superset of Go's regexp. A full overview of the syntax can be found [here](https://pkg.go.dev/gitea.twomorecents.org/Rockingcool/kleingrep/regex#hdr-Syntax).
+
+__For more information, see https://pkg.go.dev/gitea.twomorecents.org/Rockingcool/kleingrep/regex__.
+
+### How it works
+
+I've written about the inner workings of the engine [on my blog](https://twomorecents.org/writing-regex-engine/index.html).

cmd/main.go

@@ -1,225 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"flag"
-	"fmt"
-	"io"
-	"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)
-
-	invertFlag := flag.Bool("v", false, "Invert match.")
-	// This flag has two 'modes':
-	// 1. Without '-v': Prints only matches. Prints a newline after every match.
-	// 2. With '-v': Substitutes all matches with empty string.
-	onlyFlag := flag.Bool("o", false, "Print only colored content. Overrides -l.")
-	lineFlag := flag.Bool("l", false, "Only print lines with a match (or with no matches, if -v is enabled). Similar to grep's default.")
-	multiLineFlag := flag.Bool("t", false, "Multi-line mode. Treats newline just like any character.")
-	printMatchesFlag := flag.Bool("p", false, "Prints start and end index of each match. Can only be used with '-t' for multi-line mode.")
-	caseInsensitiveFlag := flag.Bool("i", false, "Case-insensitive. Disregard the case of all characters.")
-	matchNum := flag.Int("m", 0, "Print the match with the given index. Eg. -m 3 prints the third match.")
-	substituteText := flag.String("s", "", "Substitute the contents of each match with the given string. Overrides -o and -v")
-	flag.Parse()
-
-	// These flags have to be passed to the Compile function
-	if *multiLineFlag {
-		flagsToCompile = append(flagsToCompile, reg.RE_MULTILINE, reg.RE_SINGLE_LINE)
-	}
-	if *caseInsensitiveFlag {
-		flagsToCompile = append(flagsToCompile, reg.RE_CASE_INSENSITIVE)
-	}
-
-	// -l and -o are mutually exclusive: -o overrides -l
-	if *onlyFlag {
-		*lineFlag = false
-	}
-	// Check if substitute and matchNum flags have been enabled
-	substituteFlagEnabled := false
-	matchNumFlagEnabled := false
-	flag.Visit(func(f *flag.Flag) {
-		if f.Name == "s" {
-			substituteFlagEnabled = true
-		}
-		if f.Name == "m" {
-			matchNumFlagEnabled = true
-		}
-	})
-
-	// Validate matchNumFlag - must be positive integer
-	if matchNumFlagEnabled && *matchNum < 1 {
-		panic("Invalid match number to print.")
-	}
-
-	// Process:
-	// 1. Convert regex into postfix notation (Shunting-Yard algorithm)
-	// 		a. Add explicit concatenation operators to facilitate this
-	// 2. Build NFA from postfix representation (Thompson's algorithm)
-	// 3. Run the string against the NFA
-
-	if len(flag.Args()) != 1 { // flag.Args() also strips out program name
-		fmt.Println("ERROR: Missing cmdline args")
-		os.Exit(22)
-	}
-	var re string
-	re = flag.Args()[0]
-	var test_str string
-	var err error
-	var linesRead bool // Whether or not we have read the lines in the file
-	lineNum := 0       // Current line number
-	// Create reader for stdin and writer for stdout
-	reader := bufio.NewReader(os.Stdin)
-	out := bufio.NewWriter(os.Stdout)
-
-	regComp, err := reg.Compile(re, flagsToCompile...)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-	for true {
-		if linesRead {
-			break
-		}
-		if !(*multiLineFlag) {
-			// Read every string from stdin until we encounter an error. If the error isn't EOF, panic.
-			test_str, err = reader.ReadString('\n')
-			lineNum++
-			if err != nil {
-				if err == io.EOF {
-					linesRead = true
-				} else {
-					panic(err)
-				}
-			}
-			if len(test_str) > 0 && test_str[len(test_str)-1] == '\n' {
-				test_str = test_str[:len(test_str)-1]
-			}
-		} else {
-			// Multi-line mode - read every line of input into a temp. string.
-			// test_str will contain all lines of input (including newline characters)
-			// as one string.
-			var temp string
-			for temp, err = reader.ReadString('\n'); err == nil; temp, err = reader.ReadString('\n') {
-				test_str += temp
-			}
-			// Assuming err != nil
-			if err == io.EOF {
-				if len(temp) > 0 {
-					test_str += temp // Add the last line (if it is non-empty)
-				}
-				linesRead = true
-			} else {
-				panic(err)
-			}
-		}
-		matchIndices := make([]reg.Match, 0)
-		if matchNumFlagEnabled {
-			tmp, err := regComp.FindNthMatch(test_str, *matchNum)
-			if err == nil {
-				matchIndices = append(matchIndices, tmp)
-			}
-		} else {
-			matchIndices = regComp.FindAllSubmatch(test_str)
-		}
-
-		if *printMatchesFlag {
-			// if we are in single line mode, print the line on which
-			// the matches occur
-			if len(matchIndices) > 0 {
-				if !(*multiLineFlag) {
-					fmt.Fprintf(out, "Line %d:\n", lineNum)
-				}
-				for _, m := range matchIndices {
-					fmt.Fprintf(out, "%s\n", m.String())
-				}
-				err := out.Flush()
-				if err != nil {
-					panic(err)
-				}
-			}
-			continue
-		}
-		// Decompose the array of matchIndex structs into a flat unique array of ints - if matchIndex is {4,7}, flat array will contain 4,5,6
-		// 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)...)
-		}
-		// If we are inverting, then we should print the indices which _didn't_ match
-		// in color.
-		if *invertFlag {
-			oldIndices := indicesToPrint.values()
-			indicesToPrint = new_uniq_arr[int]()
-			// Explanation:
-			// Find all numbers from 0 to len(test_str) that are NOT in oldIndices.
-			// These are the values we want to print, now that we have inverted the match.
-			// Re-initialize indicesToPrint and add all of these values to it.
-			indicesToPrint.add(setDifference(genRange(0, len(test_str)), oldIndices)...)
-
-		}
-		// If lineFlag is enabled, we should only print something if:
-		// 		a. We are not inverting, and have at least one match on the current line
-		// 		OR
-		// 		b. We are inverting, and have no matches at all on the current line.
-		// This checks for the inverse, and continues if it is true.
-		if *lineFlag {
-			if !(*invertFlag) && len(matchIndices) == 0 || *invertFlag && len(matchIndices) > 0 {
-				continue
-			}
-		}
-
-		// If we are substituting, we need a different behavior, as follows:
-		// For every character in the test string:
-		// 		1. Check if the index is the start of any matchIndex
-		// 		2. If so, print the substitute text, and set our index to
-		//			the corresponding end index.
-		// 		3. If not, just print the character.
-		if substituteFlagEnabled {
-			for i := range test_str {
-				inMatchIndex := false
-				for _, m := range matchIndices {
-					if i == m[0].StartIdx {
-						fmt.Fprintf(out, "%s", *substituteText)
-						i = m[0].EndIdx
-						inMatchIndex = true
-						break
-					}
-				}
-				if !inMatchIndex {
-					fmt.Fprintf(out, "%c", test_str[i])
-				}
-			}
-		} else {
-			for i, c := range test_str {
-				if indicesToPrint.contains(i) {
-					color.New(color.FgRed).Fprintf(out, "%c", c)
-					// 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
-								fmt.Fprintf(out, "\n")
-								break
-							}
-						}
-					}
-				} else {
-					if !(*onlyFlag) {
-						fmt.Fprintf(out, "%c", c)
-					}
-				}
-			}
-		}
-		err = out.Flush()
-		if err != nil {
-			panic(err)
-		}
-		fmt.Println()
-	}
-}

kg/main.go

@@ -0,0 +1,284 @@
+package main
+
+import (
+	"bufio"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"slices"
+
+	"github.com/fatih/color"
+
+	reg "gitea.twomorecents.org/Rockingcool/kleingrep/regex"
+)
+
+func main() {
+	// Flags for the regex Compile function
+	flagsToCompile := make([]reg.ReFlag, 0)
+
+	invertFlag := flag.Bool("v", false, "Invert match.")
+	// This flag has two 'modes':
+	// 1. Without '-v': Prints only matches. Prints a newline after every match.
+	// 2. With '-v': Substitutes all matches with empty string.
+	onlyFlag := flag.Bool("o", false, "Print only colored content. Overrides -l.")
+	lineFlag := flag.Bool("l", false, "Only print lines with a match (or with no matches, if -v is enabled). Similar to grep's default.")
+	multiLineFlag := flag.Bool("t", false, "Multi-line mode. Treats newline just like any character.")
+	printMatchesFlag := flag.Bool("p", false, "Prints start and end index of each match. Can only be used with '-t' for multi-line mode.")
+	caseInsensitiveFlag := flag.Bool("i", false, "Case-insensitive. Disregard the case of all characters.")
+	recursiveFlag := flag.Bool("r", false, "Recursively search all files in the given directory.")
+	lineNumFlag := flag.Bool("n", false, "For each line with a match, print the line number. Implies -l.")
+	matchNum := flag.Int("m", 0, "Print the match with the given index. Eg. -m 3 prints the third match.")
+	substituteText := flag.String("s", "", "Substitute the contents of each match with the given string. Overrides -o and -v")
+	flag.Parse()
+
+	// These flags have to be passed to the Compile function
+	if *multiLineFlag {
+		flagsToCompile = append(flagsToCompile, reg.RE_MULTILINE, reg.RE_SINGLE_LINE)
+	}
+	if *caseInsensitiveFlag {
+		flagsToCompile = append(flagsToCompile, reg.RE_CASE_INSENSITIVE)
+	}
+
+	// -l and -o are mutually exclusive: -o overrides -l
+	if *onlyFlag {
+		*lineFlag = false
+	}
+	// Check if substitute and matchNum flags have been enabled
+	substituteFlagEnabled := false
+	matchNumFlagEnabled := false
+	flag.Visit(func(f *flag.Flag) {
+		if f.Name == "s" {
+			substituteFlagEnabled = true
+		}
+		if f.Name == "m" {
+			matchNumFlagEnabled = true
+		}
+	})
+
+	// Validate matchNumFlag - must be positive integer
+	if matchNumFlagEnabled && *matchNum < 1 {
+		panic("Invalid match number to print.")
+	}
+
+	// Enable lineFlag if lineNumFlag is enabled
+	if *lineNumFlag {
+		*lineFlag = true
+	}
+
+	// Process:
+	// 1. Convert regex into postfix notation (Shunting-Yard algorithm)
+	// 		a. Add explicit concatenation operators to facilitate this
+	// 2. Build NFA from postfix representation (Thompson's algorithm)
+	// 3. Run the string against the NFA
+
+	if len(flag.Args()) < 1 { // flag.Args() also strips out program name
+		fmt.Printf("%s: ERROR: Missing cmdline args\n", os.Args[0])
+		os.Exit(22)
+	}
+	if *recursiveFlag && len(flag.Args()) < 2 { // File/Directory must be provided with '-r'
+		fmt.Printf("%s: ERROR: Missing cmdline args\n", os.Args[0])
+		os.Exit(22)
+	}
+	var re string
+	re = flag.Args()[0]
+	var inputFiles []*os.File
+	if len(flag.Args()) == 1 || flag.Args()[1] == "-" { // Either no file argument, or file argument is "-"
+		if !slices.Contains(inputFiles, os.Stdin) {
+			inputFiles = append(inputFiles, os.Stdin) // os.Stdin cannot be entered more than once into the file list
+		}
+	} else {
+		inputFilenames := flag.Args()[1:]
+		for _, inputFilename := range inputFilenames {
+			inputFile, err := os.Open(inputFilename)
+			if err != nil {
+				fmt.Printf("%s: %s: No such file or directory\n", os.Args[0], inputFilename)
+			} else {
+				fileStat, err := inputFile.Stat()
+				if err != nil {
+					fmt.Printf("%v\n", err)
+					os.Exit(2)
+				} else {
+					if fileStat.Mode().IsDir() {
+						fmt.Printf("%s: %s: Is a directory\n", os.Args[0], inputFilename)
+					} else {
+						inputFiles = append(inputFiles, inputFile)
+					}
+				}
+			}
+		}
+	}
+
+	var test_str string
+	var err error
+	var linesRead bool // Whether or not we have read the lines in the file
+	lineNum := 0       // Current line number
+	// Create writer for stdout
+	out := bufio.NewWriter(os.Stdout)
+	// Compile regex
+	regComp, err := reg.Compile(re, flagsToCompile...)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	for _, inputFile := range inputFiles {
+		lineNum = 0
+		reader := bufio.NewReader(inputFile)
+		linesRead = false
+		for true {
+			if linesRead {
+				break
+			}
+			if !(*multiLineFlag) {
+				// Read every string from stdin until we encounter an error. If the error isn't EOF, panic.
+				test_str, err = reader.ReadString('\n')
+				lineNum++
+				if err != nil {
+					if err == io.EOF {
+						linesRead = true
+					} else {
+						panic(err)
+					}
+				}
+				if len(test_str) > 0 && test_str[len(test_str)-1] == '\n' {
+					test_str = test_str[:len(test_str)-1]
+				}
+			} else {
+				// Multi-line mode - read every line of input into a temp. string.
+				// test_str will contain all lines of input (including newline characters)
+				// as one string.
+				var temp string
+				for temp, err = reader.ReadString('\n'); err == nil; temp, err = reader.ReadString('\n') {
+					test_str += temp
+				}
+				// Assuming err != nil
+				if err == io.EOF {
+					if len(temp) > 0 {
+						test_str += temp // Add the last line (if it is non-empty)
+					}
+					linesRead = true
+				} else {
+					panic(err)
+				}
+			}
+			matchIndices := make([]reg.Match, 0)
+			if matchNumFlagEnabled {
+				tmp, err := regComp.FindNthMatch(test_str, *matchNum)
+				if err == nil {
+					matchIndices = append(matchIndices, tmp)
+				}
+			} else {
+				matchIndices = regComp.FindAllSubmatch(test_str)
+			}
+
+			test_str_runes := []rune(test_str) // Converting to runes preserves unicode characters
+
+			if *printMatchesFlag {
+				// if we are in single line mode, print the line on which
+				// the matches occur
+				if len(matchIndices) > 0 {
+					if !(*multiLineFlag) {
+						fmt.Fprintf(out, "Line %d:\n", lineNum)
+					}
+					for _, m := range matchIndices {
+						fmt.Fprintf(out, "%s\n", m.String())
+					}
+					err := out.Flush()
+					if err != nil {
+						panic(err)
+					}
+				}
+				continue
+			}
+			// Decompose the array of matchIndex structs into a flat unique array of ints - if matchIndex is {4,7}, flat array will contain 4,5,6
+			// 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)...)
+			}
+			// If we are inverting, then we should print the indices which _didn't_ match
+			// in color.
+			if *invertFlag {
+				oldIndices := indicesToPrint.values()
+				indicesToPrint = new_uniq_arr[int]()
+				// Explanation:
+				// Find all numbers from 0 to len(test_str_runes) that are NOT in oldIndices.
+				// These are the values we want to print, now that we have inverted the match.
+				// Re-initialize indicesToPrint and add all of these values to it.
+				indicesToPrint.add(setDifference(genRange(0, len(test_str_runes)), oldIndices)...)
+
+			}
+			// If lineFlag is enabled, we should only print something if:
+			// 		a. We are not inverting, and have at least one match on the current line
+			// 		OR
+			// 		b. We are inverting, and have no matches at all on the current line.
+			// This checks for the inverse, and continues if it is true.
+			if *lineFlag {
+				if !(*invertFlag) && len(matchIndices) == 0 || *invertFlag && len(matchIndices) > 0 {
+					continue
+				} else {
+					if *recursiveFlag || len(flag.Args()) > 2 { // If we have 2 args, then we're only searching 1 file. We should only print the filename if there's more than 1 file.
+						color.New(color.FgMagenta).Fprintf(out, "%s:", inputFile.Name()) // Print filename
+					}
+					if *lineNumFlag {
+						color.New(color.FgGreen).Fprintf(out, "%d:", lineNum) // Print filename
+					}
+				}
+			}
+
+			// If we are substituting, we need a different behavior, as follows:
+			// For every character in the test string:
+			// 		1. Check if the index is the start of any matchIndex
+			// 		2. If so, print the substitute text, and set our index to
+			//			the corresponding end index.
+			// 		3. If not, just print the character.
+			if substituteFlagEnabled {
+				for i := range test_str_runes {
+					inMatchIndex := false
+					for _, m := range matchIndices {
+						if i == m[0].StartIdx {
+							fmt.Fprintf(out, "%s", *substituteText)
+							i = m[0].EndIdx
+							inMatchIndex = true
+							break
+						}
+					}
+					if !inMatchIndex {
+						fmt.Fprintf(out, "%c", test_str_runes[i])
+					}
+				}
+			} else {
+				for i, c := range test_str_runes {
+					if indicesToPrint.contains(i) {
+						color.New(color.FgRed, color.Bold).Fprintf(out, "%c", c)
+						// Newline after every match - only if -o is enabled and -v is disabled.
+						if *onlyFlag && !(*invertFlag) {
+							for matchIdxNum, idx := range matchIndices {
+								if matchIdxNum < len(matchIndices)-1 { // Only print a newline afte printing a match, if there are multiple matches on the line, and we aren't on the last one. This is because the newline that gets added at the end will take care of that.
+									if i+1 == idx[0].EndIdx { // End index is one more than last index of match
+										fmt.Fprintf(out, "\n")
+										break
+									}
+								}
+							}
+						}
+					} else {
+						if !(*onlyFlag) {
+							fmt.Fprintf(out, "%c", c)
+						}
+					}
+				}
+			}
+			err = out.Flush()
+			if err != nil {
+				panic(err)
+			}
+			// If the last character in the string wasn't a newline, AND we either have don't -o set or we do (and we've matched something), then print a newline
+			if (len(test_str_runes) > 0 && test_str_runes[len(test_str_runes)-1] != '\n') &&
+				(!*onlyFlag || indicesToPrint.len() > 0) {
+				fmt.Println()
+			}
+		}
+	}
+}

kg/unique_array.go

@@ -16,7 +16,6 @@ func (s *uniq_arr[T]) add(vals ...T) {
 			s.backingMap[item] = struct{}{}
 		}
 	}
-	return
 }
 
 func (s uniq_arr[T]) contains(val T) bool {
@@ -37,3 +36,7 @@ func (s uniq_arr[T]) values() []T {
 	}
 	return toRet
 }
+
+func (s uniq_arr[T]) len() int {
+	return len(s.backingMap)
+}

regex/compile.go

@@ -12,16 +12,44 @@ var notDotChars []rune
 
 // A Reg represents the result of compiling a regular expression. It contains
 // the startState of the NFA representation of the regex, and the number of capturing
-// groups in the regex.
+// groups in the regex. It also contains the expression string.
 type Reg struct {
-	start     *nfaState
-	numGroups int
+	start         *nfaState
+	numGroups     int
+	str           string
+	preferLongest bool
 }
 
-// numSubexp eturns the number of sub-expressions in the given [Reg]. This is equivalent
+// NumSubexp returns the number of sub-expressions in the given [Reg]. This is equivalent
 // to the number of capturing groups.
-func (r Reg) NumSubexp() int {
-	return r.numGroups
+func (re Reg) NumSubexp() int {
+	return re.numGroups
+}
+
+// String returns the string used to compile the expression.
+func (re Reg) String() string {
+	return re.str
+}
+
+// MarshalText implements [encoding.TextMarshaler]. The output is equivalent to that of [Reg.String].
+// Any flags passed as arguments (including calling [Reg.Longest]) are lost.
+func (re *Reg) MarshalText() ([]byte, error) {
+	return []byte(re.String()), nil
+}
+
+// UnmarshalText implements [encoding.TextUnmarshaler]. It calls [Reg.Compile] on the given byte-slice. If it returns successfully,
+// then the result of the compilation is stored in re. The result of [Reg.Compile] is returned.
+func (re *Reg) UnmarshalText(text []byte) error {
+	newReg, err := Compile(string(text))
+	if err == nil {
+		*re = newReg
+	}
+	return err
+}
+
+// Longest makes future searches prefer the longest branch of an alternation, as opposed to the leftmost branch.
+func (re *Reg) Longest() {
+	re.preferLongest = true
 }
 
 const concatRune rune = 0xF0001
@@ -37,7 +65,7 @@ const (
 )
 
 func isOperator(c rune) bool {
-	if c == '+' || c == '?' || c == '*' || c == '|' || c == concatRune {
+	if c == '+' || c == '?' || c == '*' || c == '|' || c == concatRune || c == lazyPlusRune || c == lazyKleeneRune || c == lazyQuestionRune {
 		return true
 	}
 	return false
@@ -45,7 +73,7 @@ func isOperator(c rune) bool {
 
 /* priority returns the priority of the given operator */
 func priority(op rune) int {
-	precedence := []rune{'|', concatRune, '+', '*', '?'}
+	precedence := []rune{'|', concatRune, '+', lazyPlusRune, '*', lazyKleeneRune, '?', lazyQuestionRune}
 	return slices.Index(precedence, op)
 }
 
@@ -81,6 +109,48 @@ func getPOSIXClass(str []rune) (bool, string) {
 	return true, rtv
 }
 
+// isUnicodeCharClassLetter returns whether or not the given letter represents a unicode character class.
+func isUnicodeCharClassLetter(c rune) bool {
+	return slices.Contains([]rune{'L', 'M', 'S', 'N', 'P', 'C', 'Z'}, c)
+}
+
+// rangeTableToRuneSlice converts the given range table into a rune slice and returns it.
+func rangeTableToRuneSlice(rangetable *unicode.RangeTable) []rune {
+	var rtv []rune
+	for _, r := range rangetable.R16 {
+		for c := r.Lo; c <= r.Hi; c += r.Stride {
+			rtv = append(rtv, rune(c))
+		}
+	}
+	for _, r := range rangetable.R32 {
+		for c := r.Lo; c <= r.Hi; c += r.Stride {
+			rtv = append(rtv, rune(c))
+		}
+	}
+	return rtv
+}
+
+// unicodeCharClassToRange converts the given unicode character class name into a list of characters in that class.
+// This class could also be a single letter eg. 'C'.
+func unicodeCharClassToRange(class string) ([]rune, error) {
+	if len(class) == 0 {
+		return nil, fmt.Errorf("empty unicode character class")
+	}
+	if len(class) == 1 || len(class) == 2 {
+		if rangeTable, ok := unicode.Categories[class]; ok {
+			return rangeTableToRuneSlice(rangeTable), nil
+		} else {
+			return nil, fmt.Errorf("invalid short unicode character class")
+		}
+	} else {
+		if rangeTable, ok := unicode.Scripts[class]; ok {
+			return rangeTableToRuneSlice(rangeTable), nil
+		} else {
+			return nil, fmt.Errorf("invalid long unicode character class")
+		}
+	}
+}
+
 // Stores whether the case-insensitive flag has been enabled.
 var caseInsensitive bool
 
@@ -139,9 +209,6 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 	//		metacharacter. Later, in thompson(), these will be converted back. This avoids
 	//		confusion in detecting whether a character is escaped eg. detecting
 	// 		whether '\\[a]' has an escaped opening bracket (it doesn't).
-	//
-	// 	5. 	Check for non-greedy operators. These are not supported at the moment, so an error
-	// 		must be thrown if the user attempts to use a non-greedy operator.
 	for i := 0; i < len(re_runes_orig); i++ {
 		c := re_runes_orig[i]
 		if c == '<' && (i == 0 || (re_runes_orig[i-1] != '\\' && re_runes_orig[i-1] != '?')) {
@@ -188,8 +255,16 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 		} else if c == ']' && (i == 0 || re_runes[len(re_runes)-1] != '\\') {
 			re_runes = append(re_runes, rbracketRune)
 			continue
-		} else if slices.Contains([]rune{'+', '*', '?'}, c) && (i < len(re_runes_orig)-1 && re_runes_orig[i+1] == '?') {
-			return nil, fmt.Errorf("non-greedy operators are not supported")
+		} else if slices.Contains([]rune{'+', '*', '?'}, c) && (i > 0 && re_runes_orig[i-1] != '\\') && (i < len(re_runes_orig)-1 && re_runes_orig[i+1] == '?') {
+			switch c {
+			case '+':
+				re_runes = append(re_runes, lazyPlusRune)
+			case '*':
+				re_runes = append(re_runes, lazyKleeneRune)
+			case '?':
+				re_runes = append(re_runes, lazyQuestionRune)
+			}
+			i++
 		} else {
 			re_runes = append(re_runes, c)
 		}
@@ -282,17 +357,44 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 					}
 				} else if isHex(re_runes[i]) {
 					re_postfix = append(re_postfix, re_runes[i:i+2]...)
-					i += 2
+					i += 1 // I don't skip forward 2 steps, because the second step will happen with the loop increment
 				} else {
 					return nil, fmt.Errorf("invalid hex value in expression")
 				}
-			} else if isOctal(re_runes[i]) {
+			} else if re_runes[i] == 'p' || re_runes[i] == 'P' { // Unicode character class (P is negated unicode charclass)
+				re_postfix = append(re_postfix, re_runes[i])
+				i++
+				if i >= len(re_runes) {
+					return nil, fmt.Errorf("error parsing unicode character class in expression")
+				}
+				if re_runes[i] == '{' { // Full name charclass
+					for re_runes[i] != '}' {
+						re_postfix = append(re_postfix, re_runes[i])
+						i++
+					}
+					re_postfix = append(re_postfix, re_runes[i])
+					i++
+				} else if isUnicodeCharClassLetter(re_runes[i]) {
+					re_postfix = append(re_postfix, re_runes[i])
+					i++
+				} else {
+					return nil, fmt.Errorf("error parsing unicode character class in expression")
+				}
+				i-- // The loop increment at the top will move us forward
+			} else if re_runes[i] == '0' { // Start of octal value
 				numDigits := 1
-				for i+numDigits < len(re_runes) && numDigits < 3 && isOctal(re_runes[i+numDigits]) { // Skip while we see an octal character (max of 3)
+				for i+numDigits < len(re_runes) && numDigits < 4 && isOctal(re_runes[i+numDigits]) { // Skip while we see an octal character (max of 4, starting with 0)
 					numDigits++
 				}
 				re_postfix = append(re_postfix, re_runes[i:i+numDigits]...)
 				i += (numDigits - 1) // I have to move back a step, so that I can add a concatenation operator if necessary, and so that the increment at the bottom of the loop works as intended
+			} else if unicode.IsDigit(re_runes[i]) { // Any other number - backreference
+				numDigits := 1
+				for i+numDigits < len(re_runes) && unicode.IsDigit(re_runes[i+numDigits]) { // Skip while we see a digit
+					numDigits++
+				}
+				re_postfix = append(re_postfix, re_runes[i:i+numDigits]...)
+				i += (numDigits - 1) // Move back a step to add concatenation operator
 			} else {
 				re_postfix = append(re_postfix, re_runes[i])
 			}
@@ -309,10 +411,10 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 				if i >= len(re_runes) {
 					return nil, fmt.Errorf("unclosed lookaround")
 				}
-				if re_runes[i] == '(' || re_runes[i] == nonCapLparenRune {
+				if (re_runes[i] == '(' && re_runes[i-1] != '\\') || re_runes[i] == nonCapLparenRune {
 					numOpenParens++
 				}
-				if re_runes[i] == ')' {
+				if re_runes[i] == ')' && re_runes[i-1] != '\\' {
 					numOpenParens--
 					if numOpenParens == 0 {
 						break
@@ -325,7 +427,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 		}
 		if i < len(re_runes) && (re_runes[i] != '(' && re_runes[i] != nonCapLparenRune && re_runes[i] != '|' && re_runes[i] != '\\') || (i > 0 && re_runes[i-1] == '\\') { // Every character should be concatenated if it is escaped
 			if i < len(re_runes)-1 {
-				if re_runes[i+1] != '|' && re_runes[i+1] != '*' && re_runes[i+1] != '+' && re_runes[i+1] != '?' && re_runes[i+1] != ')' && re_runes[i+1] != '{' {
+				if re_runes[i+1] != '|' && re_runes[i+1] != '*' && re_runes[i+1] != lazyKleeneRune && re_runes[i+1] != '+' && re_runes[i+1] != lazyPlusRune && re_runes[i+1] != '?' && re_runes[i+1] != lazyQuestionRune && re_runes[i+1] != ')' && re_runes[i+1] != '{' {
 					re_postfix = append(re_postfix, concatRune)
 				}
 			}
@@ -337,7 +439,9 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 	outQueue := make([]postfixNode, 0) // Output queue
 
 	// Actual algorithm
-	numOpenParens := 0 // Number of open parentheses
+	numOpenParens := 0                               // Number of open parentheses
+	parenIndices := make([]Group, 0)                 // I really shouldn't be using Group here, because that's strictly for matching purposes, but its a convenient way to store the indices of the opening and closing parens.
+	parenIndices = append(parenIndices, Group{0, 0}) // I append a weird value here, because the 0-th group doesn't have any parens. This way, the 1st group will be at index 1, 2nd at 2 ...
 	for i := 0; i < len(re_postfix); i++ {
 		/* Two cases:
 		1. Current character is alphanumeric - send to output queue
@@ -393,11 +497,44 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 				} else {
 					return nil, fmt.Errorf("not enough hex characters found in expression")
 				}
-			} else if isOctal(re_postfix[i]) { // Octal value
+			} else if re_postfix[i] == 'p' || re_postfix[i] == 'P' {
+				charClassInverted := (re_postfix[i] == 'P')
+				var charsInClass []rune
+				i++
+				if isUnicodeCharClassLetter(re_postfix[i]) {
+					var err error
+					charsInClass, err = unicodeCharClassToRange(string(re_postfix[i]))
+					if err != nil {
+						return nil, err
+					}
+				} else if re_postfix[i] == '{' {
+					i++ // Skip opening bracket
+					unicodeCharClassStr := ""
+					for re_postfix[i] != '}' {
+						unicodeCharClassStr += string(re_postfix[i])
+						i++
+					}
+					var err error
+					charsInClass, err = unicodeCharClassToRange(unicodeCharClassStr)
+					if err != nil {
+						return nil, err
+					}
+				} else {
+					return nil, fmt.Errorf("error parsing unicode character class in expression")
+				}
+				var toAppend postfixNode
+				if !charClassInverted { // \p
+					toAppend = newPostfixNode(charsInClass...)
+				} else { // \P
+					toAppend = newPostfixDotNode()
+					toAppend.except = append([]postfixNode{}, newPostfixNode(charsInClass...))
+				}
+				outQueue = append(outQueue, toAppend)
+			} else if re_postfix[i] == '0' { // Octal value
 				var octVal int64
 				var octValStr string
 				numDigitsParsed := 0
-				for (i+numDigitsParsed) < len(re_postfix) && isOctal(re_postfix[i+numDigitsParsed]) && numDigitsParsed <= 3 {
+				for (i+numDigitsParsed) < len(re_postfix) && isOctal(re_postfix[i+numDigitsParsed]) && numDigitsParsed <= 4 {
 					octValStr += string(re_postfix[i+numDigitsParsed])
 					numDigitsParsed++
 				}
@@ -410,6 +547,20 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 				}
 				i += numDigitsParsed - 1 // Shift forward by the number of digits that were parsed. Move back one character, because the loop increment will move us back to the next character automatically
 				outQueue = append(outQueue, newPostfixCharNode(rune(octVal)))
+			} else if unicode.IsDigit(re_postfix[i]) { // Backreference
+				var num int64
+				var numStr string
+				numDigitsParsed := 0
+				for (i+numDigitsParsed) < len(re_postfix) && unicode.IsDigit(re_postfix[i+numDigitsParsed]) {
+					numStr += string(re_postfix[i+numDigitsParsed])
+					numDigitsParsed++
+				}
+				num, err := strconv.ParseInt(numStr, 10, 32)
+				if err != nil {
+					return nil, fmt.Errorf("error parsing backreference in expresion")
+				}
+				i += numDigitsParsed - 1
+				outQueue = append(outQueue, newPostfixBackreferenceNode(int(num)))
 			} else {
 				escapedNode, err := newEscapedNode(re_postfix[i], false)
 				if err != nil {
@@ -439,10 +590,10 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 				if i >= len(re_postfix) {
 					return nil, fmt.Errorf("unclosed lookaround")
 				}
-				if re_postfix[i] == '(' || re_postfix[i] == nonCapLparenRune {
+				if (re_postfix[i] == '(' && re_postfix[i-1] != '\\') || re_postfix[i] == nonCapLparenRune {
 					numOpenParens++
 				}
-				if re_postfix[i] == ')' {
+				if re_postfix[i] == ')' && re_postfix[i-1] != '\\' {
 					numOpenParens--
 					if numOpenParens == 0 {
 						break
@@ -561,11 +712,44 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 						} else {
 							return nil, fmt.Errorf("not enough hex characters found in character class")
 						}
-					} else if isOctal(re_postfix[i]) { // Octal value
+					} else if re_postfix[i] == 'p' || re_postfix[i] == 'P' {
+						charClassInverted := (re_postfix[i] == 'P')
+						var charsInList []rune
+						i++
+						if isUnicodeCharClassLetter(re_postfix[i]) {
+							var err error
+							charsInList, err = unicodeCharClassToRange(string(re_postfix[i]))
+							if err != nil {
+								return nil, err
+							}
+						} else if re_postfix[i] == '{' {
+							i++ // Skip opening bracket
+							unicodeCharClassStr := ""
+							for re_postfix[i] != '}' {
+								unicodeCharClassStr += string(re_postfix[i])
+								i++
+							}
+							var err error
+							charsInList, err = unicodeCharClassToRange(unicodeCharClassStr)
+							if err != nil {
+								return nil, err
+							}
+						} else {
+							return nil, fmt.Errorf("error parsing unicode character class in expression")
+						}
+						if !charClassInverted {
+							chars = append(chars, newPostfixNode(charsInList...))
+						} else {
+							toAppend := newPostfixDotNode()
+							toAppend.except = append([]postfixNode{}, newPostfixNode(charsInList...))
+							chars = append(chars, toAppend)
+						}
+					} else if re_postfix[i] == '0' { // Octal value
+
 						var octVal int64
 						var octValStr string
 						numDigitsParsed := 0
-						for (i+numDigitsParsed) < len(re_postfix)-1 && isOctal(re_postfix[i+numDigitsParsed]) && numDigitsParsed <= 3 { // The '-1' exists, because even in the worst case (the character class extends till the end), the last character must be a closing bracket (and nothing else)
+						for (i+numDigitsParsed) < len(re_postfix)-1 && isOctal(re_postfix[i+numDigitsParsed]) && numDigitsParsed <= 4 { // The '-1' exists, because even in the worst case (the character class extends till the end), the last character must be a closing bracket (and nothing else)
 							octValStr += string(re_postfix[i+numDigitsParsed])
 							numDigitsParsed++
 						}
@@ -762,6 +946,10 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 			}
 			outQueue[idx].startReps = startRangeNum
 			outQueue[idx].endReps = endRangeNum
+			if i < len(re_postfix)-1 && re_postfix[i+1] == '?' { // lazy repitition
+				outQueue[idx].isLazy = true
+				i++
+			}
 		}
 		if c == '(' || c == nonCapLparenRune {
 			opStack = append(opStack, c)
@@ -769,6 +957,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 				outQueue = append(outQueue, newPostfixNode(c))
 			}
 			numOpenParens++
+			parenIndices = append(parenIndices, Group{StartIdx: len(outQueue) - 1}) // Push the index of the lparen into parenIndices
 		}
 		if c == ')' {
 			// Keep popping from opStack until we encounter an opening parantheses or a NONCAPLPAREN_CHAR. Throw error if we reach the end of the stack.
@@ -785,6 +974,7 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 			if val == '(' {       // Whatever was inside the parentheses was a _capturing_ group, so we append the closing parentheses as well
 				outQueue = append(outQueue, newPostfixNode(')')) // Add closing parentheses
 			}
+			parenIndices[numOpenParens].EndIdx = len(outQueue) - 1
 			numOpenParens--
 		}
 	}
@@ -799,6 +989,11 @@ func shuntingYard(re string, flags ...ReFlag) ([]postfixNode, error) {
 		return nil, fmt.Errorf("imbalanced parantheses")
 	}
 
+	//	outQueue, _, err := rewriteBackreferences(outQueue, parenIndices)
+	//	if err != nil {
+	//		return nil, err
+	//	}
+
 	return outQueue, nil
 }
 
@@ -816,13 +1011,12 @@ func thompson(re []postfixNode) (Reg, error) {
 	// In these cases, we will return an NFA with 1 state, with an assertion that is always true.
 	if len(re) == 0 {
 		start := zeroLengthMatchState()
-		nfa = append(nfa, &start)
+		nfa = append(nfa, start)
 	}
 
 	for _, c := range re {
 		if c.nodetype == characterNode || c.nodetype == assertionNode {
 			stateToAdd := nfaState{}
-			stateToAdd.transitions = make(map[int][]*nfaState)
 			if c.allChars {
 				stateToAdd.allChars = true
 				if len(c.except) != 0 {
@@ -934,7 +1128,6 @@ func thompson(re []postfixNode) (Reg, error) {
 			s.isEmpty = true
 			s.output = make([]*nfaState, 0)
 			s.output = append(s.output, s)
-			s.transitions = make(map[int][]*nfaState)
 			// LPAREN nodes are just added normally
 			if c.nodetype == lparenNode {
 				numGroups++
@@ -966,7 +1159,7 @@ func thompson(re []postfixNode) (Reg, error) {
 					s.groupNum = lparenNode.groupNum
 					to_add := concatenate(lparenNode, s)
 					nfa = append(nfa, to_add)
-				} else if middleNode.groupBegin && len(middleNode.transitions) == 0 { // The middle node is a lone lparen - something like '(())', and I'm looking at the first rparen
+				} else if middleNode.groupBegin && middleNode.numTransitions() == 0 { // The middle node is a lone lparen - something like '(())', and I'm looking at the first rparen
 					nfa = append(nfa, lparenNode)    // I shouldn't have popped this out, because it is not involved in the current capturing group
 					s.groupNum = middleNode.groupNum // In this case, the 'middle' node is actually an lparen
 					to_add := concatenate(middleNode, s)
@@ -989,7 +1182,8 @@ func thompson(re []postfixNode) (Reg, error) {
 		if c.nodetype == charclassNode { // A Character class consists of all the nodes in it, alternated
 			// Map the list of nodes to a list of states, each state containing the contents of a specific node
 			states := funcMap(c.nodeContents, func(node postfixNode) *nfaState {
-				s := newState()
+				s := &nfaState{}
+				s.output = append(s.output, s)
 				nodeContents := node.contents
 				if caseInsensitive {
 					nodeContents = slices.Concat(funcMap(nodeContents, func(r rune) []rune {
@@ -1003,7 +1197,7 @@ func thompson(re []postfixNode) (Reg, error) {
 						return n.contents
 					})...)
 				}
-				return &s
+				return s
 			})
 			// Reduce the list of states down to a single state by alternating them
 			toAdd := funcReduce(states, func(s1 *nfaState, s2 *nfaState) *nfaState {
@@ -1011,6 +1205,21 @@ func thompson(re []postfixNode) (Reg, error) {
 			})
 			nfa = append(nfa, toAdd)
 		}
+		if c.nodetype == backreferenceNode {
+			if c.referencedGroup > numGroups {
+				return Reg{}, fmt.Errorf("invalid backreference")
+			}
+			stateToAdd := &nfaState{}
+			stateToAdd.assert = noneAssert
+			stateToAdd.content = newContents(epsilon)
+			stateToAdd.isEmpty = true
+			stateToAdd.isBackreference = true
+			stateToAdd.output = make([]*nfaState, 0)
+			stateToAdd.output = append(stateToAdd.output, stateToAdd)
+			stateToAdd.referredGroup = c.referencedGroup
+			stateToAdd.threadBackref = 0
+			nfa = append(nfa, stateToAdd)
+		}
 		// Must be an operator if it isn't a character
 		switch c.nodetype {
 		case concatenateNode:
@@ -1030,17 +1239,23 @@ func thompson(re []postfixNode) (Reg, error) {
 			if err != nil {
 				return Reg{}, fmt.Errorf("error applying kleene star")
 			}
-			stateToAdd, err := kleene(*s1)
+			stateToAdd, err := kleene(s1)
 			if err != nil {
 				return Reg{}, err
 			}
+			if c.isLazy {
+				stateToAdd.isLazy = true
+			}
 			nfa = append(nfa, stateToAdd)
 		case plusNode: // a+ is equivalent to aa*
 			s1 := mustPop(&nfa)
-			s2, err := kleene(*s1)
+			s2, err := kleene(s1)
 			if err != nil {
 				return Reg{}, err
 			}
+			if c.isLazy {
+				s2.isLazy = true
+			}
 			s1 = concatenate(s1, s2)
 			nfa = append(nfa, s1)
 		case questionNode: // ab? is equivalent to a(b|)
@@ -1048,7 +1263,13 @@ func thompson(re []postfixNode) (Reg, error) {
 			if err != nil {
 				return Reg{}, fmt.Errorf("error applying question operator")
 			}
-			s2 := question(s1)
+			s2, err := question(s1)
+			if err != nil {
+				return Reg{}, err
+			}
+			if c.isLazy {
+				s2.isLazy = true
+			}
 			nfa = append(nfa, s2)
 		case pipeNode:
 			// A pipe operator doesn't actually need either operand to be present. If an operand isn't present,
@@ -1061,19 +1282,19 @@ func thompson(re []postfixNode) (Reg, error) {
 			// 	'^|a'
 			s2, err1 := pop(&nfa)
 			s1, err2 := pop(&nfa)
-			if err2 != nil || (s2.groupBegin && len(s2.transitions) == 0) { // Doesn't exist, or its just an LPAREN
+			if err2 != nil || (s2.groupBegin && s2.numTransitions() == 0) { // Doesn't exist, or its just an LPAREN
 				if err2 == nil { // Roundabout way of saying that this node existed, but it was an LPAREN, so we append it back
 					nfa = append(nfa, s2)
 				}
 				tmp := zeroLengthMatchState()
-				s2 = &tmp
+				s2 = tmp
 			}
-			if err1 != nil || (s1.groupBegin && len(s1.transitions) == 0) { // Doesn't exist, or its just an LPAREN
+			if err1 != nil || (s1.groupBegin && s1.numTransitions() == 0) { // Doesn't exist, or its just an LPAREN
 				if err1 == nil { // See above for explanation
 					nfa = append(nfa, s1)
 				}
 				tmp := zeroLengthMatchState()
-				s1 = &tmp
+				s1 = tmp
 			}
 			s3 := alternate(s1, s2)
 			nfa = append(nfa, s3)
@@ -1100,14 +1321,24 @@ func thompson(re []postfixNode) (Reg, error) {
 				stateToAdd = concatenate(stateToAdd, cloneState(poppedState))
 			}
 			if c.endReps == infinite_reps { // Case 3
-				s2, err := kleene(*poppedState)
+				s2, err := kleene(poppedState)
 				if err != nil {
 					return Reg{}, err
 				}
+				if c.isLazy {
+					s2.isLazy = true
+				}
 				stateToAdd = concatenate(stateToAdd, s2)
 			} else { // Case 2
 				for i := c.startReps; i < c.endReps; i++ {
-					stateToAdd = concatenate(stateToAdd, question(cloneState(poppedState)))
+					tmp, err := question(cloneState(poppedState))
+					if err != nil {
+						return Reg{}, fmt.Errorf("error processing bounded repetition")
+					}
+					if c.isLazy {
+						tmp.isLazy = true
+					}
+					stateToAdd = concatenate(stateToAdd, tmp)
 				}
 			}
 			nfa = append(nfa, stateToAdd)
@@ -1117,9 +1348,13 @@ func thompson(re []postfixNode) (Reg, error) {
 		return Reg{}, fmt.Errorf("invalid regex")
 	}
 
-	verifyLastStates(nfa)
+	lastState := newState()
+	lastState.isLast = true
 
-	return Reg{nfa[0], numGroups}, nil
+	concatenate(nfa[0], &lastState)
+
+	// The string is empty here, because we add it in Compile()
+	return Reg{nfa[0], numGroups, "", false}, nil
 
 }
 
@@ -1137,10 +1372,11 @@ func Compile(re string, flags ...ReFlag) (Reg, error) {
 	if err != nil {
 		return Reg{}, fmt.Errorf("error compiling regex: %w", err)
 	}
+	reg.str = re
 	return reg, nil
 }
 
-// MustCompile panicks if Compile returns an error. They are identical in all other respects.
+// MustCompile panics if Compile returns an error. They are identical in all other respects.
 func MustCompile(re string, flags ...ReFlag) Reg {
 	reg, err := Compile(re, flags...)
 	if err != nil {

regex/doc.go

@@ -4,6 +4,8 @@ Package regex implements regular expression search, using a custom non-bracktrac
 The engine relies completely on UTF-8 codepoints. As such, it is capable of matching characters
 from other languages, emojis and symbols.
 
+The API and regex syntax are largely compatible with that of the stdlib's [regexp], with a few key differences (see 'Key Differences with regexp').
+
 The full syntax is specified below.
 
 # Syntax
@@ -16,7 +18,7 @@ Single characters:
 	[^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)
+	\0452			Match the character with the octal value 452 (up to 4 digits, first digit must be 0)
 	\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
@@ -31,7 +33,7 @@ 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_])
+	\W				Match any non-word character ([^a-zA-Z0-9_])
 	\s				Match any whitespace character ([ \t\n])
 	\S				Match any non-whitespace character ([^ \t\n])
 
@@ -55,17 +57,27 @@ POSIX classes (inside normal character classes):
 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
+	x|y				Match x or y (prefer x)
+	xy|z			Match xy or z (prefer xy)
 
-Repitition (always greedy, preferring more):
+Repitition:
 
-	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)
+	Greedy:
+	x*				Match x zero or more times, prefer more
+	x+				Match x one or more times, prefer more
+	x?				Match x zero or one time, prefer one
+	x{m,n}			Match x between m and n times (inclusive), prefer more
+	x{m,}			Match x atleast m times, prefer more
+	x{,n}			Match x between 0 and n times (inclusive), prefer more
+	x{m}			Match x exactly m times
+
+	Lazy:
+	x*?				Match x zero or more times, prefer fewer
+	x+?				Match x one or more times, prefer fewer
+	x??				Match x zero or one time, prefer zero
+	x{m,n}?			Match x between m and n times (inclusive), prefer fewer
+	x{m,}?			Match x atleast m times, prefer fewer
+	x{,n}?			Match x between 0 and n times (inclusive), prefer fewer
 	x{m}			Match x exactly m times
 
 Grouping:
@@ -91,48 +103,33 @@ Lookarounds:
 	(?<=x)y			Positive lookbehind - Match y if preceded by x
 	(?<!x)y			Negative lookbehind - Match y if NOT preceded by x
 
+Backreferences:
+
+	(xy)\1			Match 'xy' followed by the text most recently captured by group 1 (in this case, 'xy')
+
 Numeric ranges:
 
 	<x-y>			Match any number from x to y (inclusive) (x and y must be positive numbers)
+	\<x				Match a literal '<' followed by x
 
 # Key Differences with regexp
 
-The engine and the API differ from [regexp] in a number of ways, some of them very subtle.
+The engine and the API differ from [regexp] in a few 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:
+1. 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
+2. 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:
+equivalent expression for this engine is shown below. Note that 'Index' is the default.
 
 	Find(All)?(String)?(Submatch)?
 
@@ -140,7 +137,7 @@ equivalent expression for this engine is:
 
 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 'String' it returns the matched text, rather than the index in the string.
 
 If a function contains 'Submatch' it returns the match, including all submatches found by
 capturing groups.
@@ -156,5 +153,21 @@ and the input string:
 
 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.
+
+# Feature Differences
+
+The following features from [regexp] are (currently) NOT supported:
+ 1. Named capturing groups
+ 2. Negated POSIX classes
+ 3. Embedded flags (flags are instead passed as arguments to [Compile])
+ 4. Literal text with \Q ... \E
+ 5. Finite repetition with no start (defaulting at 0)
+
+The following features are not available in [regexp], but are supported in my engine:
+ 1. Lookarounds
+ 2. Numeric ranges
+ 3. Backreferences
+
+I hope to shorten the first list, and expand the second.
 */
 package regex

regex/example_test.go

@@ -2,6 +2,7 @@ package regex_test
 
 import (
 	"fmt"
+	"strings"
 
 	"gitea.twomorecents.org/Rockingcool/kleingrep/regex"
 )
@@ -32,12 +33,12 @@ func ExampleReg_FindAll() {
 }
 
 func ExampleReg_FindString() {
-	regexStr := `\d+`
+	regexStr := `\w+\s+(?=sheep)`
 	regexComp := regex.MustCompile(regexStr)
 
-	matchStr := regexComp.FindString("The year of our lord, 2025")
+	matchStr := regexComp.FindString("pink cows and yellow sheep")
 	fmt.Println(matchStr)
-	// Output: 2025
+	// Output: yellow
 }
 
 func ExampleReg_FindSubmatch() {
@@ -52,3 +53,129 @@ func ExampleReg_FindSubmatch() {
 	// 0	1
 	// 2	3
 }
+
+func ExampleReg_FindStringSubmatch() {
+	regexStr := `(\d{4})-(\d{2})-(\d{2})`
+	regexComp := regex.MustCompile(regexStr)
+	inputStr := `The date is 2025-02-10`
+
+	match := regexComp.FindStringSubmatch(inputStr)
+	fmt.Println(match[1])
+	fmt.Println(match[3])
+	// Output: 2025
+	// 10
+}
+
+func ExampleReg_FindAllSubmatch() {
+	regexStr := `(\d)\.(\d)(\d)`
+	regexComp := regex.MustCompile(regexStr)
+
+	matches := regexComp.FindAllSubmatch("3.14+8.97")
+	fmt.Println(matches[0][0]) // 0-group (entire match) of 1st match (0-indexed)
+	fmt.Println(matches[0][1]) // 1st group of 1st match
+	fmt.Println(matches[1][0]) // 0-group of 2nd match
+	fmt.Println(matches[1][1]) // 1st group of 2nd math
+	// Output: 0	4
+	// 0	1
+	// 5	9
+	// 5	6
+}
+
+func ExampleReg_FindAllString() {
+	regexStr := `<0-255>\.<0-255>\.<0-255>\.<0-255>`
+	inputStr := `192.168.220.7 pings 9.9.9.9`
+	regexComp := regex.MustCompile(regexStr)
+
+	matchStrs := regexComp.FindAllString(inputStr)
+
+	fmt.Println(matchStrs[0])
+	fmt.Println(matchStrs[1])
+	// Output: 192.168.220.7
+	// 9.9.9.9
+}
+
+func ExampleReg_FindAllStringSubmatch() {
+	// 'https' ...
+	// followed by 1 or more alphanumeric characters (including period) ...
+	// then a forward slash ...
+	// followed by one more of :
+	// 		word character,
+	// 		question mark,
+	// 		period,
+	// 		equals sign
+	regexStr := `https://([a-z0-9\.]+)/([\w.?=]+)`
+	regexComp := regex.MustCompile(regexStr, regex.RE_CASE_INSENSITIVE)
+	inputStr := `You can find me at https://twomorecents.org/index.html and https://news.ycombinator.com/user?id=aadhavans`
+
+	matchIndices := regexComp.FindAllStringSubmatch(inputStr)
+	fmt.Println(matchIndices[0][1]) // 1st group of 1st match (0-indexed)
+	fmt.Println(matchIndices[0][2]) // 2nd group of 1st match
+	fmt.Println(matchIndices[1][1]) // 1st group of 2nd match
+	fmt.Println(matchIndices[1][2]) // 2nd group of 2nd match
+	// Output: twomorecents.org
+	// index.html
+	// news.ycombinator.com
+	// user?id=aadhavans
+
+}
+
+func ExampleReg_Expand() {
+	inputStr := `option1: value1
+	option2: value2`
+	regexStr := `(\w+): (\w+)`
+	templateStr := "$1 = $2\n"
+	regexComp := regex.MustCompile(regexStr, regex.RE_MULTILINE)
+	result := ""
+	for _, submatches := range regexComp.FindAllSubmatch(inputStr) {
+		result = regexComp.Expand(result, templateStr, inputStr, submatches)
+	}
+	fmt.Println(result)
+	// Output: option1 = value1
+	// option2 = value2
+
+}
+
+func ExampleReg_LiteralPrefix() {
+	regexStr := `a(b|c)d*`
+	regexComp := regex.MustCompile(regexStr)
+	prefix, complete := regexComp.LiteralPrefix()
+	fmt.Println(prefix)
+	fmt.Println(complete)
+	// Output: a
+	// false
+}
+
+func ExampleReg_Longest() {
+	regexStr := `x|xx`
+	inputStr := "xx"
+	regexComp := regex.MustCompile(regexStr)
+	fmt.Println(regexComp.FindString(inputStr))
+	regexComp.Longest()
+	fmt.Println(regexComp.FindString(inputStr))
+	// Output: x
+	// xx
+}
+
+func ExampleReg_ReplaceAll() {
+	regexStr := `(\d)(\w)`
+	inputStr := "5d9t"
+	regexComp := regex.MustCompile(regexStr)
+	fmt.Println(regexComp.ReplaceAll(inputStr, `$2$1`))
+	// Output: d5t9
+}
+
+func ExampleReg_ReplaceAllLiteral() {
+	regexStr := `fox|dog`
+	inputStr := "the quick brown fox jumped over the lazy dog"
+	regexComp := regex.MustCompile(regexStr)
+	fmt.Println(regexComp.ReplaceAllLiteral(inputStr, `duck`))
+	// Output: the quick brown duck jumped over the lazy duck
+}
+
+func ExampleReg_ReplaceAllFunc() {
+	regexStr := `\w{5,}`
+	inputStr := `all five or more letter words in this string are capitalized`
+	regexComp := regex.MustCompile(regexStr)
+	fmt.Println(regexComp.ReplaceAllFunc(inputStr, strings.ToUpper))
+	// Output: all five or more LETTER WORDS in this STRING are CAPITALIZED
+}

regex/matching.go

@@ -2,8 +2,8 @@ package regex
 
 import (
 	"fmt"
-	"slices"
-	"sort"
+	"strconv"
+	"unicode"
 )
 
 // A Match represents a match found by the regex in a given string.
@@ -15,7 +15,7 @@ import (
 // See [Reg.FindSubmatch] for an example.
 type Match []Group
 
-// a Group represents a group. It contains the start index and end index of the match
+// a Group represents a capturing group. It contains the start and index of the group.
 type Group struct {
 	StartIdx int
 	EndIdx   int
@@ -30,17 +30,6 @@ func newMatch(size int) Match {
 	return toRet
 }
 
-// Returns the number of valid groups in the match
-func (m Match) numValidGroups() int {
-	numValid := 0
-	for _, g := range m {
-		if g.StartIdx >= 0 && g.EndIdx >= 0 {
-			numValid++
-		}
-	}
-	return numValid
-}
-
 // Returns a string containing the indices of all (valid) groups in the match
 func (m Match) String() string {
 	var toRet string
@@ -59,7 +48,7 @@ func (idx Group) String() string {
 	return fmt.Sprintf("%d\t%d", idx.StartIdx, idx.EndIdx)
 }
 
-// Returns whether a group is valid (ie. whether it matched any text). It
+// IsValid 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
@@ -70,106 +59,42 @@ func getZeroGroup(m Match) Group {
 	return m[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) {
-	for _, state := range states {
-		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
-					//					openParenGroups = append(openParenGroups, s.groupNum)
-				}
-				if s.groupEnd {
-					s.threadGroups[s.groupNum].EndIdx = idx
-					//					closeParenGroups = append(closeParenGroups, s.groupNum)
-				}
-			}
-			rtv = append(rtv, state.transitions[epsilon]...)
-		}
-	}
-	for _, state := range rtv {
-		if len(state.transitions[epsilon]) > 0 {
-			return rtv, true
-		}
-	}
-	return rtv, false
-}
-
-// zeroMatchPossible returns true if a zero-length match is possible
-// 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 {
-	zeroStates, isZero := takeZeroState(states, numGroups, idx)
-	tempstates := make([]*nfaState, 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...)
-		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 {
-			return true
-		}
-	}
-	return false
-}
-
-// Prunes the slice by removing overlapping indices.
-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
-	})
-	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 {
-			toRet = append(toRet, current)
-			current = idx
-		} else if idx[0].EndIdx > current[0].EndIdx {
-			// idx overlaps, but it is longer, so update current
-			current = idx
-		}
-	}
-	// Add last state
-	toRet = append(toRet, current)
-	return toRet
-}
-
 func copyThread(to *nfaState, from nfaState) {
-	to.threadSP = from.threadSP
 	to.threadGroups = append([]Group{}, from.threadGroups...)
 }
 
 // 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)
+func (re Reg) Find(str string) (Group, error) {
+	match, err := re.FindNthMatch(str, 1)
 	if err != nil {
 		return Group{}, fmt.Errorf("no matches found")
 	}
 	return getZeroGroup(match), nil
 }
 
+// Match returns a boolean value, indicating whether the regex found a match in the given string.
+func (re Reg) Match(str string) bool {
+	_, err := re.Find(str)
+	return err == nil
+}
+
+// CompileMatch compiles expr and returns true if str contains a match of the expression.
+// It is equivalent to [regexp.Match].
+// An optional list of flags may be provided (see [ReFlag]).
+// It returns an error (!= nil) if there was an error compiling the expression.
+func CompileMatch(expr string, str string, flags ...ReFlag) (bool, error) {
+	re, err := Compile(expr, flags...)
+	if err != nil {
+		return false, err
+	}
+	return re.Match(str), 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)
+func (re Reg) FindAll(str string) []Group {
+	indices := re.FindAllSubmatch(str)
 	zeroGroups := funcMap(indices, getZeroGroup)
 	return zeroGroups
 }
@@ -178,8 +103,8 @@ func (regex Reg) FindAll(str string) []Group {
 // 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 (re Reg) FindString(str string) string {
+	match, err := re.FindNthMatch(str, 1)
 	if err != nil {
 		return ""
 	}
@@ -192,8 +117,8 @@ func (regex Reg) FindString(str string) string {
 // 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)
+func (re Reg) FindSubmatch(str string) (Match, error) {
+	match, err := re.FindNthMatch(str, 1)
 	if err != nil {
 		return Match{}, fmt.Errorf("no match found")
 	} else {
@@ -201,11 +126,41 @@ func (regex Reg) FindSubmatch(str string) (Match, error) {
 	}
 }
 
-// FindAllString is the 'all' version of FindString.
+// FindStringSubmatch is the 'string' version of [FindSubmatch]. It returns a slice of strings,
+// where the string at index i contains the text matched by the i-th capturing group.
+// The 0-th index represents the entire match.
+// An empty string at index n could mean:
+// ,
+//  1. Group n did not find a match
+//  2. Group n found a zero-length match
+//
+// A return value of nil indicates no match.
+func (re Reg) FindStringSubmatch(str string) []string {
+	matchStr := make([]string, re.numGroups+1)
+	match, err := re.FindSubmatch(str)
+	if err != nil {
+		return nil
+	}
+	nonEmptyMatchFound := false
+	for i := range match {
+		if match[i].IsValid() {
+			matchStr[i] = str[match[i].StartIdx:match[i].EndIdx]
+			nonEmptyMatchFound = true
+		} else {
+			matchStr[i] = ""
+		}
+	}
+	if nonEmptyMatchFound == false {
+		return nil
+	}
+	return matchStr
+}
+
+// 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)
+func (re Reg) FindAllString(str string) []string {
+	zerogroups := re.FindAll(str)
 	matchStrs := funcMap(zerogroups, func(g Group) string {
 		return str[g.StartIdx:g.EndIdx]
 	})
@@ -214,14 +169,14 @@ func (regex Reg) FindAllString(str string) []string {
 
 // FindNthMatch return the 'n'th match of the regex in 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 (re Reg) FindNthMatch(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 = findAllSubmatchHelper(re.start, str_runes, idx, re.numGroups, re.preferLongest)
 		if matchFound {
 			matchNum++
 		}
@@ -234,31 +189,90 @@ func (regex Reg) FindNthMatch(str string, n int) (Match, error) {
 }
 
 // FindAllSubmatch returns a slice of matches in the given string.
-func (regex Reg) FindAllSubmatch(str string) []Match {
+func (re Reg) FindAllSubmatch(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 = findAllSubmatchHelper(re.start, str_runes, idx, re.numGroups, re.preferLongest)
 		if matchFound {
 			indices = append(indices, matchIdx)
 		}
 	}
-	if len(indices) > 0 {
-		return pruneIndices(indices)
-	}
 
 	return indices
 }
 
+// FindAllSubmatch returns a double-slice of strings. Each slice contains the text of a match, including all submatches.
+// A return value of nil indicates no match.
+func (re Reg) FindAllStringSubmatch(str string) [][]string {
+	match := re.FindAllSubmatch(str)
+	if len(match) == 0 {
+		return nil
+	}
+	rtv := make([][]string, len(match))
+	for i := range rtv {
+		rtv[i] = make([]string, re.numGroups+1)
+	}
+	rtv = funcMap(match, func(m Match) []string {
+		return funcMap(m, func(g Group) string {
+			if g.IsValid() {
+				return str[g.StartIdx:g.EndIdx]
+			} else {
+				return ""
+			}
+		})
+	})
+	return rtv
+}
+
+func addStateToList(str []rune, idx int, list []nfaState, state nfaState, threadGroups []Group, visited []nfaState, preferLongest bool) []nfaState {
+	if stateExists(list, state) || stateExists(visited, state) {
+		return list
+	}
+	visited = append(visited, state)
+
+	if (state.isKleene || state.isQuestion) && (state.isLazy == false) { // Greedy quantifiers
+		copyThread(state.splitState, state)
+		list := addStateToList(str, idx, list, *state.splitState, threadGroups, visited, preferLongest)
+		copyThread(state.next, state)
+		list = addStateToList(str, idx, list, *state.next, threadGroups, visited, preferLongest)
+		return list
+	}
+	if state.isAlternation || ((state.isKleene || state.isQuestion) && state.isLazy) { // Alternation or lazy quantifier
+		copyThread(state.next, state)
+		list := addStateToList(str, idx, list, *state.next, threadGroups, visited, preferLongest)
+		copyThread(state.splitState, state)
+		list = addStateToList(str, idx, list, *state.splitState, threadGroups, visited, preferLongest)
+		return list
+	}
+	state.threadGroups = append([]Group{}, threadGroups...)
+	if state.assert != noneAssert {
+		if state.checkAssertion(str, idx, preferLongest) {
+			copyThread(state.next, state)
+			return addStateToList(str, idx, list, *state.next, state.threadGroups, visited, preferLongest)
+		}
+	}
+	if state.groupBegin {
+		state.threadGroups[state.groupNum].StartIdx = idx
+		copyThread(state.next, state)
+		return addStateToList(str, idx, list, *state.next, state.threadGroups, visited, preferLongest)
+	}
+	if state.groupEnd {
+		state.threadGroups[state.groupNum].EndIdx = idx
+		copyThread(state.next, state)
+		return addStateToList(str, idx, list, *state.next, state.threadGroups, visited, preferLongest)
+	}
+	return append(list, state)
+
+}
+
 // Helper for FindAllMatches. Returns whether it found a match, the
 // first Match it finds, and how far it got into the string ie. where
 // 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 findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups int, preferLongest bool) (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)
@@ -266,373 +280,197 @@ func findAllSubmatchHelper(start *nfaState, str []rune, offset int, numGroups in
 	}
 	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
-	// chosen as the match for the entire string.
-	// This allows us to pick the longest possible match (which is how greedy matching works).
-	// COMMENT ABOVE IS CURRENTLY NOT UP-TO-DATE
-	//	tempIndices := newMatch(numGroups + 1)
-
-	//	foundPath := false
-	//startIdx := offset
-	//endIdx := offset
 	currentStates := make([]nfaState, 0)
 	nextStates := 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
 
 	// If the first state is an assertion, makes sure the assertion
 	// is true before we do _anything_ else.
 	if start.assert != noneAssert {
-		if start.checkAssertion(str, offset) == false {
+		if start.checkAssertion(str, offset, preferLongest) == false {
 			i++
 			return false, []Group{}, i
 		}
 	}
-	// Increment until we hit a character matching the start state (assuming not 0-state)
-	//	if start.isEmpty == false {
-	//		for i < len(str) && !start.contentContains(str, i) {
-	//			i++
-	//		}
-	//		startIdx = i
-	//		startingFrom = i
-	//		i++ // Advance to next character (if we aren't at a 0-state, which doesn't match anything), so that we can check for transitions. If we advance at a 0-state, we will never get a chance to match the first character
-	//	}
 
-	//	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
-	//		tempIndices[start.groupNum].startIdx = i
-	//}
-
-	start.threadSP = i
-	currentStates = append(currentStates, *start)
-	var foundMatch bool
-	var isEmptyAndNoAssertion bool
-	// Main loop
+	start.threadGroups = newMatch(numGroups + 1)
+	start.threadGroups[0].StartIdx = i
+	currentStates = addStateToList(str, i, currentStates, *start, start.threadGroups, nil, preferLongest)
+	var match Match = nil
 	for idx := i; idx <= len(str); idx++ {
+		if len(currentStates) == 0 {
+			break
+		}
 		for currentStateIdx := 0; currentStateIdx < len(currentStates); currentStateIdx++ {
 			currentState := currentStates[currentStateIdx]
-			foundMatch = false
-			isEmptyAndNoAssertion = false
 
 			if currentState.threadGroups == nil {
 				currentState.threadGroups = newMatch(numGroups + 1)
 				currentState.threadGroups[0].StartIdx = idx
 			}
 
-			if currentState.groupBegin {
-				currentState.threadGroups[currentState.groupNum].StartIdx = idx
-				//		allMatches := make([]nfaState, 0)
-				//		for _, v := range currentState.transitions {
-				//			dereferenced := funcMap(v, func(s *nfaState) nfaState {
-				//				return *s
-				//			})
-				//			allMatches = append(allMatches, dereferenced...)
-				//		}
-				//		slices.Reverse(allMatches)
-				//		for i := range allMatches {
-				//			copyThread(&allMatches[i], currentState)
-				//		}
-				//		currentStates = append(currentStates, allMatches...)
-			}
-			if currentState.groupEnd {
-				currentState.threadGroups[currentState.groupNum].EndIdx = idx
-				//			allMatches := make([]nfaState, 0)
-				//			for _, v := range currentState.transitions {
-				//				dereferenced := funcMap(v, func(s *nfaState) nfaState {
-				//					return *s
-				//				})
-				//				allMatches = append(allMatches, dereferenced...)
-				//			}
-				//			slices.Reverse(allMatches)
-				//			for i := range allMatches {
-				//				copyThread(&allMatches[i], currentState)
-				//			}
-				//			currentStates = append(currentStates, allMatches...)
-			}
-
-			//		if currentState.isKleene {
-			//			// Append the next-state (after the kleene), then append the kleene state
-			//			allMatches := make([]*nfaState, 0)
-			//			for _, v := range currentState.transitions {
-			//				allMatches = append(allMatches, v...)
-			//			}
-			//			slices.Reverse(allMatches)
-			//			for _, m := range allMatches {
-			//				m.threadGroups = currentState.threadGroups
-			//				m.threadSP = idx
-			//			}
-			//			currentStates = append(currentStates, allMatches...)
-			//
-			//			//	kleeneState := currentState.kleeneState
-			//			//	kleeneState.threadGroups = currentState.threadGroups
-			//			//	kleeneState.threadSP = currentState.threadSP
-			//			//	currentStates = append(currentStates, kleeneState)
-			//			continue
-			//		}
-
-			// Alternation - enqueue left then right state, and continue
-			if currentState.isAlternation {
-				leftState := currentState.leftState
-				copyThread(leftState, currentState)
-				currentStates = append(currentStates, *currentState.leftState)
-				rightState := currentState.rightState
-				copyThread(rightState, currentState)
-				currentStates = append(currentStates, *currentState.rightState)
-				continue
-			}
-
-			// Empty state - enqueue next state, do _not_ increment the SP
-			if currentState.isEmpty && currentState.assert == noneAssert { //&& currentState.groupBegin == false && currentState.groupEnd == false {
-				isEmptyAndNoAssertion = true
-			}
-
-			if currentState.contentContains(str, idx) {
-				foundMatch = true
-			}
-
-			if isEmptyAndNoAssertion || foundMatch {
-				allMatches := make([]nfaState, 0)
-				for _, v := range currentState.transitions {
-					dereferenced := funcMap(v, func(s *nfaState) nfaState {
-						return *s
-					})
-					allMatches = append(allMatches, dereferenced...)
+			if currentState.isLast {
+				currentState.threadGroups[0].EndIdx = idx
+				match = append([]Group{}, currentState.threadGroups...)
+				if !preferLongest {
+					break
 				}
-				slices.Reverse(allMatches)
-				for i := range allMatches {
-					copyThread(&allMatches[i], currentState)
-					if foundMatch && currentState.assert == noneAssert {
-						allMatches[i].threadSP += 1
-					}
+			} else if !currentState.isAlternation && !currentState.isKleene && !currentState.isQuestion && !currentState.isBackreference && !currentState.groupBegin && !currentState.groupEnd && currentState.assert == noneAssert { // Normal character
+				if currentState.contentContains(str, idx, preferLongest) {
+					nextStates = addStateToList(str, idx+1, nextStates, *currentState.next, currentState.threadGroups, nil, preferLongest)
 				}
-				if currentState.groupBegin {
-					currentStates = slices.Insert(currentStates, currentStateIdx+1, allMatches...)
-				} else if currentState.groupEnd {
-					currentStates = append(currentStates, allMatches...)
+			} else if currentState.isBackreference && currentState.threadGroups[currentState.referredGroup].IsValid() {
+				groupLength := currentState.threadGroups[currentState.referredGroup].EndIdx - currentState.threadGroups[currentState.referredGroup].StartIdx
+				if currentState.threadBackref == groupLength {
+					currentState.threadBackref = 0
+					copyThread(currentState.next, currentState)
+					currentStates = addStateToList(str, idx, currentStates, *currentState.next, currentState.threadGroups, nil, preferLongest)
 				} else {
-					nextStates = append(nextStates, allMatches...)
+					idxInReferredGroup := currentState.threadGroups[currentState.referredGroup].StartIdx + currentState.threadBackref
+					if idxInReferredGroup < len(str) && idx < len(str) && str[idxInReferredGroup] == str[idx] {
+						currentState.threadBackref += 1
+						nextStates = append(nextStates, currentState)
+					}
 				}
 			}
 
-			if currentState.isLast && len(nextStates) == 0 { // Last state reached
-				if foundMatch {
-					if currentState.assert != noneAssert {
-						currentState.threadGroups[0].EndIdx = idx
-					} else {
-						currentState.threadGroups[0].EndIdx = idx + 1
-					}
-					if idx == currentState.threadGroups[0].StartIdx {
-						idx += 1
-					}
-					return true, currentState.threadGroups, idx
-				} else if isEmptyAndNoAssertion {
-					currentState.threadGroups[0].EndIdx = idx
-					if idx == currentState.threadGroups[0].StartIdx {
-						idx++
-					}
-					return true, currentState.threadGroups, idx
-				}
-
-			}
 		}
 		currentStates = append([]nfaState{}, nextStates...)
 		nextStates = nil
 	}
+	if match != nil {
+		if offset == match[0].EndIdx {
+			return true, match, match[0].EndIdx + 1
+		}
+		return true, match, match[0].EndIdx
+	}
 	return false, []Group{}, i + 1
-	//		zeroStates := make([]*nfaState, 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.
-	//		topStateItem := currentStates.peek()
-	//		topState := topStateItem.(*priorQueueItem).state
-	//		zeroStates, isZero := takeZeroState([]*nfaState{topState}, numGroups, i)
-	//		tempStates = append(tempStates, zeroStates...)
-	//		num_appended := 0
-	//		for isZero == true {
-	//			zeroStates, isZero = takeZeroState(tempStates, numGroups, i)
-	//			tempStates, num_appended = uniqueAppend(tempStates, zeroStates...)
-	//			if num_appended == 0 { // Break if we haven't appended any more unique values
-	//				break
-	//			}
-	//		}
-	//		if isZero == true {
-	//			currentStates.Pop()
-	//		}
-	//
-	//		for _, state := range tempStates {
-	//			heap.Push(currentStates, newPriorQueueItem(state))
-	//		}
-	//		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
-	//		for numStatesMatched == 0 && lastStateInList == false {
-	//			if currentStates.Len() == 0 {
-	//				break
-	//			}
-	//			stateItem := heap.Pop(currentStates)
-	//			state := stateItem.(*priorQueueItem).state
-	//			matches, numMatches := state.matchesFor(str, i)
-	//			if numMatches > 0 {
-	//				numStatesMatched++
-	//				tempStates = append([]*nfaState(nil), matches...)
-	//				foundPath = true
-	//				for _, m := range matches {
-	//					if m.threadGroups == nil {
-	//						m.threadGroups = newMatch(numGroups + 1)
-	//					}
-	//					m.threadSP = state.threadSP + 1
-	//					copy(m.threadGroups, state.threadGroups)
-	//				}
-	//			}
-	//			if numMatches < 0 {
-	//				assertionFailed = true
-	//			}
-	//			if state.isLast {
-	//				if state.isLookaround() {
-	//					lastLookaroundInList = true
-	//				}
-	//				lastStateInList = true
-	//				lastStatePtr = state
-	//			}
-	//		}
-	//
-	//		if assertionFailed && numStatesMatched == 0 { // Nothing has matched and an assertion has failed
-	//			// If I'm being completely honest, I'm not sure why I have to check specifically for a _lookaround_
-	//			// state. The explanation below is my attempt to explain this behavior.
-	//			// If you replace 'lastLookaroundInList' with 'lastStateInList', one of the test cases fails.
-	//			//
-	//			// One of the states in our list was a last state and a lookaround. In this case, we
-	//			// don't abort upon failure of the assertion, because we have found
-	//			// another path to a final state.
-	//			// Even if the last state _was_ an assertion, we can use the previously
-	//			// saved indices to find a match.
-	//			if lastLookaroundInList {
-	//				break
-	//			} else {
-	//				if i == startingFrom {
-	//					i++
-	//				}
-	//				return false, []Group{}, i
-	//			}
-	//		}
-	//		// Check if we can find a state in our list that is:
-	//		// 	a. A last-state
-	//		// 	b. Empty
-	//		// 	c. Doesn't assert anything
-	//		for _, stateItem := range *currentStates {
-	//			s := stateItem.state
-	//			if s.isLast && s.isEmpty && s.assert == noneAssert {
-	//				lastStatePtr = s
-	//				lastStateInList = true
-	//			}
-	//		}
-	//		if lastStateInList && numStatesMatched == 0 { // A last-state was in the list of states. add the matchIndex to our MatchIndex list
-	//			for j := 1; j < numGroups+1; j++ {
-	//				tempIndices[j] = lastStatePtr.threadGroups[j]
-	//			}
-	//			endIdx = i
-	//			tempIndices[0] = Group{startIdx, endIdx}
-	//			if tempIndices[0].StartIdx == tempIndices[0].EndIdx {
-	//				return true, tempIndices, tempIndices[0].EndIdx + 1
-	//			} else {
-	//				return true, tempIndices, tempIndices[0].EndIdx
-	//			}
-	//		}
-	//
-	//		// Check if we can find a zero-length match
-	//		if foundPath == false {
-	//			currentStatesList := funcMap(*currentStates, func(item *priorQueueItem) *nfaState {
-	//				return item.state
-	//			})
-	//			if ok := zeroMatchPossible(str, i, numGroups, currentStatesList...); ok {
-	//				if tempIndices[0].IsValid() == false {
-	//					tempIndices[0] = Group{startIdx, startIdx}
-	//				}
-	//			}
-	//			// If we haven't moved in the string, increment the counter by 1
-	//			// to ensure we don't keep trying the same string over and over.
-	//			//			if i == startingFrom {
-	//			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
-	//				} else {
-	//					return true, tempIndices, tempIndices[0].EndIdx
-	//				}
-	//			}
-	//			return false, []Group{}, startIdx
-	//		}
-	//		currentStates = &priorityQueue{}
-	//		slices.Reverse(tempStates)
-	//		for _, state := range tempStates {
-	//			heap.Push(currentStates, newPriorQueueItem(state))
-	//		}
-	//		tempStates = nil
-	//
-	//		i++
-	//	}
-	//
-	// // End-of-string reached. Go to any 0-states, until there are no more 0-states to go to. Then check if any of our states are in the end position.
-	// // This is the exact same algorithm used inside the loop, so I should probably put it in a function.
-	//
-	//	if currentStates.Len() > 0 {
-	//		topStateItem := currentStates.peek()
-	//		topState := topStateItem.(*priorQueueItem).state
-	//		zeroStates, isZero := takeZeroState([]*nfaState{topState}, numGroups, i)
-	//		tempStates = append(tempStates, zeroStates...)
-	//		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...)
-	//			if num_appended == 0 { // Break if we haven't appended any more unique values
-	//				break
-	//			}
-	//		}
-	//	}
-	//
-	//	for _, state := range tempStates {
-	//		heap.Push(currentStates, newPriorQueueItem(state))
-	//	}
-	//
-	// tempStates = nil
-	//
-	//	for _, stateItem := range *currentStates {
-	//		state := stateItem.state
-	//		// 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) {
-	//				for j := 1; j < numGroups+1; j++ {
-	//					tempIndices[j] = state.threadGroups[j]
-	//				}
-	//				endIdx = i
-	//				tempIndices[0] = Group{startIdx, endIdx}
-	//			}
-	//		}
-	//	}
-	//
-	//	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
-	//		} else {
-	//			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.
-	//
-	//		startIdx++
-	//	}
-	//
-	// return false, []Group{}, startIdx
+}
+
+// Expand appends template to dst, expanding any variables in template to the relevant capturing group.
+//
+// A variable is of the form '$n', where 'n' is a number. It will be replaced by the contents of the n-th capturing group.
+// To insert a literal $, do not put a number after it. Alternatively, you can use $$.
+// src is the input string, and match must be the result of [Reg.FindSubmatch].
+func (re Reg) Expand(dst string, template string, src string, match Match) string {
+	templateRuneSlc := []rune(template)
+	srcRuneSlc := []rune(src)
+	i := 0
+	for i < len(templateRuneSlc) {
+		c := templateRuneSlc[i]
+		if c == '$' {
+			i += 1
+			// The dollar sign is the last character of the string, or it is proceeded by another dollar sign
+			if i >= len(templateRuneSlc) || templateRuneSlc[i] == '$' {
+				dst += "$"
+				i++
+			} else {
+				numStr := ""
+				for i < len(templateRuneSlc) && unicode.IsDigit(templateRuneSlc[i]) {
+					numStr += string(templateRuneSlc[i])
+					i++
+				}
+				if numStr == "" {
+					dst += "$"
+				} else {
+					num, _ := strconv.Atoi(numStr)
+					if num < len(match) {
+						dst += string(srcRuneSlc[match[num].StartIdx:match[num].EndIdx])
+					} else {
+						dst += "$" + numStr
+					}
+				}
+			}
+		} else {
+			dst += string(c)
+			i++
+		}
+	}
+	return dst
+}
+
+// LiteralPrefix returns a string that must begin any match of the given regular expression.
+// The second return value is true if the string comprises the entire expression.
+func (re Reg) LiteralPrefix() (prefix string, complete bool) {
+	state := re.start
+	if state.assert != noneAssert {
+		state = state.next
+	}
+	for !(state.isLast) && (!state.isAlternation) && len(state.content) == 1 && state.assert == noneAssert {
+		if state.groupBegin || state.groupEnd {
+			state = state.next
+			continue
+		}
+		prefix += string(rune(state.content[0]))
+		state = state.next
+	}
+	if state.isLast {
+		complete = true
+	} else {
+		complete = false
+	}
+	return prefix, complete
+}
+
+// ReplaceAll replaces all matches of the expression in src, with the text in repl. In repl, variables are interpreted
+// as they are in [Reg.Expand]. The resulting string is returned.
+func (re Reg) ReplaceAll(src string, repl string) string {
+	matches := re.FindAllSubmatch(src)
+	i := 0
+	currentMatch := 0
+	dst := ""
+	for i < len(src) {
+		if currentMatch < len(matches) && matches[currentMatch][0].IsValid() && i == matches[currentMatch][0].StartIdx {
+			dst += re.Expand("", repl, src, matches[currentMatch])
+			i = matches[currentMatch][0].EndIdx
+			currentMatch++
+		} else {
+			dst += string(src[i])
+			i++
+		}
+	}
+	return dst
+}
+
+// ReplaceAllLiteral replaces all matches of the expression in src, with the text in repl. The text is replaced directly,
+// without any expansion.
+func (re Reg) ReplaceAllLiteral(src string, repl string) string {
+	zerogroups := re.FindAll(src)
+	currentMatch := 0
+	i := 0
+	dst := ""
+
+	for i < len(src) {
+		if currentMatch < len(zerogroups) && i == zerogroups[currentMatch].StartIdx {
+			dst += repl
+			i = zerogroups[currentMatch].EndIdx
+			currentMatch += 1
+		} else {
+			dst += string(src[i])
+			i++
+		}
+	}
+	return dst
+}
+
+// ReplaceAllFunc replaces every match of the expression in src, with the return value of the function replFunc.
+// replFunc takes in the matched string. The return value is substituted in directly without expasion.
+func (re Reg) ReplaceAllFunc(src string, replFunc func(string) string) string {
+	zerogroups := re.FindAll(src)
+	currentMatch := 0
+	i := 0
+	dst := ""
+
+	for i < len(src) {
+		if currentMatch < len(zerogroups) && i == zerogroups[currentMatch].StartIdx {
+			dst += replFunc(src[zerogroups[currentMatch].StartIdx:zerogroups[currentMatch].EndIdx])
+			i = zerogroups[currentMatch].EndIdx
+			currentMatch += 1
+		} else {
+			dst += string(src[i])
+			i++
+		}
+	}
+	return dst
+
 }

regex/misc.go

@@ -16,8 +16,11 @@ 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 lazyKleeneRune rune = 0xF000A   // Represents a lazy kleene star
+var lazyPlusRune rune = 0xF000B     // Represents a lazy plus operator
+var lazyQuestionRune rune = 0xF000C // Represents a lazy question operator
 
-var specialChars = []rune{'?', '*', '\\', '^', '$', '{', '}', '(', ')', '[', ']', '+', '|', '.', concatRune, '<', '>', lbracketRune, rbracketRune, nonCapLparenRune}
+var specialChars = []rune{'?', lazyQuestionRune, '*', lazyKleeneRune, '\\', '^', '$', '{', '}', '(', ')', '[', ']', '+', lazyPlusRune, '|', '.', concatRune, '<', '>', lbracketRune, rbracketRune, nonCapLparenRune}
 
 // An interface for int and rune, which are identical
 type character interface {
@@ -48,49 +51,6 @@ func isNormalChar(c rune) bool {
 	return !slices.Contains(specialChars, c)
 }
 
-// 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) {
-	num_appended := 0
-	for _, item := range items {
-		if !slices.Contains(slc, item) {
-			slc = append(slc, item)
-			num_appended++
-		}
-	}
-	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]
-	for _, item := range items {
-		if item != first {
-			return false
-		}
-	}
-	return true
-}
-
 // 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 {

regex/nfa.go

@@ -25,29 +25,31 @@ const (
 )
 
 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
-	isQuestion                 bool                // Identifies whether current node is a 0-state representing the question operator
-	isAlternation              bool                // Identifies whether current node is a 0-state representing an alternation
-	leftState                  *nfaState           // Only for alternation states - the 'left' branch of the alternation
-	rightState                 *nfaState           // Only for alternation states - the 'right' branch of the alternation
-	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
+	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)
+	next                       *nfaState  // The next state (not for alternation or kleene states)
+	isKleene                   bool       // Identifies whether current node is a 0-state representing Kleene star
+	isQuestion                 bool       // Identifies whether current node is a 0-state representing the question operator
+	isAlternation              bool       // Identifies whether current node is a 0-state representing an alternation
+	isLazy                     bool       // Only for split states - Identifies whether or not to flip the order of branches (try one branch before the other)
+	splitState                 *nfaState  // Only for alternation states - the 'other' branch of the alternation ('next' is the first)
+	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
+	isBackreference            bool       // Whether or not current node is backreference
+	referredGroup              int        // If current node is a backreference, the node that it points to
 	// 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.
-	threadSP       int     // The string pointer of the thread - where it is in the input string
+	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.
+	threadBackref int     // If current node is a backreference, how many characters to look forward into the referred group
 }
 
 // Clones the NFA starting from the given state.
@@ -73,18 +75,19 @@ func cloneStateHelper(stateToClone *nfaState, cloneMap map[*nfaState]*nfaState)
 		isEmpty:         stateToClone.isEmpty,
 		isLast:          stateToClone.isLast,
 		output:          make([]*nfaState, len(stateToClone.output)),
-		transitions:     make(map[int][]*nfaState),
 		isKleene:        stateToClone.isKleene,
 		isQuestion:      stateToClone.isQuestion,
 		isAlternation:   stateToClone.isAlternation,
+		isLazy:          stateToClone.isLazy,
 		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,
+		isBackreference: stateToClone.isBackreference,
+		referredGroup:   stateToClone.referredGroup,
 	}
 	cloneMap[stateToClone] = clone
 	for i, s := range stateToClone.output {
@@ -94,28 +97,18 @@ func cloneStateHelper(stateToClone *nfaState, cloneMap map[*nfaState]*nfaState)
 			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)
-	if stateToClone.leftState == stateToClone {
-		clone.leftState = clone
+	if stateToClone.splitState == stateToClone {
+		clone.splitState = clone
 	}
-	clone.leftState = cloneStateHelper(stateToClone.leftState, cloneMap)
-	if stateToClone.rightState == stateToClone {
-		clone.rightState = clone
+	clone.splitState = cloneStateHelper(stateToClone.splitState, cloneMap)
+	if stateToClone.next == stateToClone {
+		clone.next = clone
 	}
-	clone.rightState = cloneStateHelper(stateToClone.rightState, cloneMap)
+	clone.next = cloneStateHelper(stateToClone.next, cloneMap)
 	return clone
 }
 
@@ -126,23 +119,27 @@ func resetThreads(start *nfaState) {
 }
 
 func resetThreadsHelper(state *nfaState, visitedMap map[*nfaState]bool) {
+	if state == nil {
+		return
+	}
 	if _, ok := visitedMap[state]; ok {
 		return
 	}
 	// Assuming it hasn't been visited
 	state.threadGroups = nil
-	state.threadSP = 0
+	state.threadBackref = 0
 	visitedMap[state] = true
-	for _, v := range state.transitions {
-		for _, nextState := range v {
-			resetThreadsHelper(nextState, visitedMap)
-		}
+	if state.isAlternation {
+		resetThreadsHelper(state.next, visitedMap)
+		resetThreadsHelper(state.splitState, visitedMap)
+	} else {
+		resetThreadsHelper(state.next, 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 {
+func (s nfaState) checkAssertion(str []rune, idx int, preferLongest bool) bool {
 	if s.assert == alwaysTrueAssert {
 		return true
 	}
@@ -192,7 +189,7 @@ func (s nfaState) checkAssertion(str []rune, idx int) bool {
 			strToMatch = string(runesToMatch)
 		}
 
-		regComp := Reg{startState, s.lookaroundNumCaptureGroups}
+		regComp := Reg{startState, s.lookaroundNumCaptureGroups, s.lookaroundRegex, preferLongest}
 		matchIndices := regComp.FindAll(strToMatch)
 
 		numMatchesFound := 0
@@ -219,9 +216,9 @@ func (s nfaState) checkAssertion(str []rune, idx int) bool {
 }
 
 // Returns true if the contents of 's' contain the value at the given index of the given string
-func (s nfaState) contentContains(str []rune, idx int) bool {
+func (s nfaState) contentContains(str []rune, idx int, preferLongest bool) bool {
 	if s.assert != noneAssert {
-		return s.checkAssertion(str, idx)
+		return s.checkAssertion(str, idx, preferLongest)
 	}
 	if idx >= len(str) {
 		return false
@@ -237,74 +234,84 @@ func (s nfaState) isLookaround() bool {
 	return s.assert == plaAssert || s.assert == plbAssert || s.assert == nlaAssert || s.assert == nlbAssert
 }
 
+func (s nfaState) numTransitions() int {
+	if s.next == nil && s.splitState == nil {
+		return 0
+	}
+	if s.next == nil || s.splitState == nil {
+		return 1
+	}
+	return 2
+}
+
 // 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
-}
+//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)
-			}
-		}
-	}
-}
+//func verifyLastStatesHelper(st *nfaState, visited map[*nfaState]bool) {
+//	if st.numTransitions() == 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 st.numTransitions() == 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))
-}
+//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 {
@@ -312,81 +319,84 @@ func concatenate(s1 *nfaState, s2 *nfaState) *nfaState {
 		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[i].next = s2
 	}
 	s1.output = s2.output
 	return s1
 }
 
-func kleene(s1 nfaState) (*nfaState, error) {
+func kleene(s1 *nfaState) (*nfaState, error) {
 	if s1.isEmpty && s1.assert != noneAssert {
 		return nil, fmt.Errorf("previous token is not quantifiable")
 	}
 
-	emptyState := zeroLengthMatchState()
-	emptyState.assert = noneAssert
-	toReturn := alternate(&s1, &emptyState)
+	toReturn := &nfaState{}
+	toReturn.isEmpty = true
+	toReturn.isAlternation = true
+	toReturn.content = newContents(epsilon)
+	toReturn.splitState = s1
 
 	//	toReturn := &nfaState{}
 	//	toReturn.transitions = make(map[int][]*nfaState)
 	//	toReturn.content = newContents(epsilon)
-	toReturn.isEmpty = true
 	toReturn.isKleene = true
-	toReturn.output = []*nfaState{&emptyState}
+	toReturn.output = append([]*nfaState{}, 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)
+		s1.output[i].next = toReturn
 	}
+	//	for _, c := range s1.content {
+	//		toReturn.transitions[c], _ = uniqueAppend(toReturn.transitions[c], &s1)
+	//	}
 	//toReturn.kleeneState = &s1
 	return toReturn, nil
 }
 
 func alternate(s1 *nfaState, s2 *nfaState) *nfaState {
 	toReturn := &nfaState{}
-	toReturn.transitions = make(map[int][]*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)
-	}
+	//	// 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
 	toReturn.isAlternation = true
-	toReturn.leftState = s1
-	toReturn.rightState = s2
+	toReturn.next = s1
+	toReturn.splitState = s2
 
 	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
+func question(s1 *nfaState) (*nfaState, error) { // Use the fact that ab? == a(b|)
+	if s1.isEmpty && s1.assert != noneAssert {
+		return nil, fmt.Errorf("previous token is not quantifiable")
+	}
+	toReturn := &nfaState{}
+	toReturn.isEmpty = true
+	toReturn.isAlternation = true
+	toReturn.isQuestion = true
+	toReturn.content = newContents(epsilon)
+	toReturn.splitState = s1
+	toReturn.output = append([]*nfaState{}, toReturn)
+	toReturn.output = append(toReturn.output, s1.output...)
+	//	s2.transitions = make(map[int][]*nfaState)
+	return toReturn, nil
 }
 
 // Creates and returns a new state with the 'default' values.
 func newState() nfaState {
 	ret := nfaState{
-		output:          make([]*nfaState, 0),
-		transitions:     make(map[int][]*nfaState),
+		output: make([]*nfaState, 0),
+		//		transitions:     make(map[int][]*nfaState),
 		assert:          noneAssert,
 		except:          append([]rune{}, 0),
 		lookaroundRegex: "",
@@ -398,10 +408,42 @@ func newState() nfaState {
 }
 
 // Creates and returns a state that _always_ has a zero-length match.
-func zeroLengthMatchState() nfaState {
-	start := newState()
+func zeroLengthMatchState() *nfaState {
+	start := &nfaState{}
 	start.content = newContents(epsilon)
 	start.isEmpty = true
 	start.assert = alwaysTrueAssert
+	start.output = append([]*nfaState{}, start)
 	return start
 }
+
+func (s nfaState) equals(other nfaState) bool {
+	return s.isEmpty == other.isEmpty &&
+		s.isLast == other.isLast &&
+		slices.Equal(s.output, other.output) &&
+		slices.Equal(s.content, other.content) &&
+		s.next == other.next &&
+		s.isKleene == other.isKleene &&
+		s.isQuestion == other.isQuestion &&
+		s.isLazy == other.isLazy &&
+		s.isAlternation == other.isAlternation &&
+		s.splitState == other.splitState &&
+		s.assert == other.assert &&
+		s.allChars == other.allChars &&
+		slices.Equal(s.except, other.except) &&
+		s.lookaroundNFA == other.lookaroundNFA &&
+		s.groupBegin == other.groupBegin &&
+		s.groupEnd == other.groupEnd &&
+		s.groupNum == other.groupNum &&
+		slices.Equal(s.threadGroups, other.threadGroups) &&
+		s.threadBackref == other.threadBackref
+}
+
+func stateExists(list []nfaState, s nfaState) bool {
+	for i := range list {
+		if list[i].equals(s) {
+			return true
+		}
+	}
+	return false
+}

regex/postfixNode.go

@@ -1,6 +1,8 @@
 package regex
 
-import "fmt"
+import (
+	"fmt"
+)
 
 type nodeType int
 
@@ -20,6 +22,7 @@ const (
 	assertionNode
 	lparenNode
 	rparenNode
+	backreferenceNode
 )
 
 // Helper constants for lookarounds
@@ -31,15 +34,17 @@ const lookbehind = -1
 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
-	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
-	allChars       bool          // Whether or not the current node represents all characters (eg. dot metacharacter)
-	except         []postfixNode // For inverted character classes, we match every unicode character _except_ a few. In this case, allChars is true and the exceptions are placed here.
-	lookaroundSign int           // ONLY USED WHEN nodetype == ASSERTION. Whether we have a positive or negative lookaround.
-	lookaroundDir  int           // Lookbehind or lookahead
-	nodeContents   []postfixNode // ONLY USED WHEN nodetype == CHARCLASS. Holds all the nodes inside the given CHARCLASS node.
+	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
+	allChars        bool          // Whether or not the current node represents all characters (eg. dot metacharacter)
+	except          []postfixNode // For inverted character classes, we match every unicode character _except_ a few. In this case, allChars is true and the exceptions are placed here.
+	lookaroundSign  int           // ONLY USED WHEN nodetype == ASSERTION. Whether we have a positive or negative lookaround.
+	lookaroundDir   int           // Lookbehind or lookahead
+	nodeContents    []postfixNode // ONLY USED WHEN nodetype == CHARCLASS. Holds all the nodes inside the given CHARCLASS node.
+	referencedGroup int           // ONLY USED WHEN nodetype == backreferenceNode. Holds the group which this one refers to. After parsing is done, the expression will be rewritten eg. (a)\1 will become (a)(a). So the return value of ShuntingYard() shouldn't contain a backreferenceNode.
+	isLazy          bool          // ONLY USED WHEN nodetype == kleene or question
 }
 
 // Converts the given list of postfixNodes to one node of type CHARCLASS.
@@ -158,10 +163,19 @@ func newPostfixNode(contents ...rune) postfixNode {
 		switch contents[0] {
 		case '+':
 			to_return.nodetype = plusNode
+		case lazyPlusRune:
+			to_return.nodetype = plusNode
+			to_return.isLazy = true
 		case '?':
 			to_return.nodetype = questionNode
+		case lazyQuestionRune:
+			to_return.nodetype = questionNode
+			to_return.isLazy = true
 		case '*':
 			to_return.nodetype = kleeneNode
+		case lazyKleeneRune:
+			to_return.nodetype = kleeneNode
+			to_return.isLazy = true
 		case '|':
 			to_return.nodetype = pipeNode
 		case concatRune:
@@ -208,3 +222,44 @@ func newPostfixCharNode(contents ...rune) postfixNode {
 	toReturn.contents = append(toReturn.contents, contents...)
 	return toReturn
 }
+
+// newPostfixBackreferenceNode creates and returns a backreference node, referring to the given group
+func newPostfixBackreferenceNode(referred int) postfixNode {
+	toReturn := postfixNode{}
+	toReturn.startReps = 1
+	toReturn.endReps = 1
+	toReturn.nodetype = backreferenceNode
+	toReturn.referencedGroup = referred
+	return toReturn
+}
+
+// rewriteBackreferences rewrites any backreferences in the given postfixNode slice, into their respective groups.
+// It stores the relation in a map, and returns it as the second return value.
+// It uses parenIndices to determine where a group starts and ends in nodes.
+// For example, \1(a) will be rewritten into (a)(a), and 1 -> 2 will be the hashmap value.
+// It returns an error if a backreference points to an invalid group.
+// func rewriteBackreferences(nodes []postfixNode, parenIndices []Group) ([]postfixNode, map[int]int, error) {
+// 	rtv := make([]postfixNode, 0)
+// 	referMap := make(map[int]int)
+// 	numGroups := 0
+// 	groupIncrement := 0 // If we have a backreference before the group its referring to, then the group its referring to will have its group number incremented.
+// 	for i, node := range nodes {
+// 		if node.nodetype == backreferenceNode {
+// 			if node.referencedGroup >= len(parenIndices) {
+// 				return nil, nil, fmt.Errorf("invalid backreference")
+// 			}
+// 			rtv = slices.Concat(rtv, nodes[parenIndices[node.referencedGroup].StartIdx:parenIndices[node.referencedGroup].EndIdx+1]) // Add all the nodes in the group to rtv
+// 			numGroups += 1
+// 			if i < parenIndices[node.referencedGroup].StartIdx {
+// 				groupIncrement += 1
+// 			}
+// 			referMap[numGroups] = node.referencedGroup + groupIncrement
+// 		} else {
+// 			rtv = append(rtv, node)
+// 			if node.nodetype == lparenNode {
+// 				numGroups += 1
+// 			}
+// 		}
+// 	}
+// 	return rtv, referMap, nil
+// }

regex/priorityQueue.go

@@ -1,89 +0,0 @@
-package regex
-
-import "container/heap"
-
-// Implement a priority queue using container/heap
-
-const (
-	min_priority int = iota
-	zerostate_priority
-	alternation_priority
-	kleene_priority
-	char_priority
-	max_priority
-)
-
-func getPriority(state *nfaState) int {
-	if state.isKleene {
-		return zerostate_priority
-	} else if state.isAlternation {
-		return alternation_priority
-	} else {
-		if state.isEmpty {
-			return zerostate_priority
-		} else {
-			return char_priority
-		}
-	}
-}
-
-type priorQueueItem struct {
-	state    *nfaState
-	priority int
-	index    int
-}
-
-func newPriorQueueItem(state *nfaState) *priorQueueItem {
-	return &priorQueueItem{
-		state:    state,
-		index:    -1,
-		priority: getPriority(state),
-	}
-}
-
-type priorityQueue []*priorQueueItem
-
-func (pq priorityQueue) Len() int {
-	return len(pq)
-}
-
-func (pq priorityQueue) Less(i, j int) bool {
-	if pq[i].priority == pq[j].priority {
-		return pq[i].index < pq[j].index
-	}
-	return pq[i].priority > pq[j].priority // We want max-heap, so we use greater-than
-}
-
-func (pq priorityQueue) Swap(i, j int) {
-	pq[i], pq[j] = pq[j], pq[i]
-	pq[i].index = i
-	pq[j].index = j
-}
-
-func (pq *priorityQueue) Push(x any) {
-	length := len(*pq)
-	item := x.(*priorQueueItem)
-	item.index = length
-	*pq = append(*pq, item)
-}
-
-func (pq *priorityQueue) Pop() any {
-	old := *pq
-	n := len(old)
-	item := old[n-1]
-	old[n-1] = nil
-	item.index = -1
-	*pq = old[0 : n-1]
-	return item
-}
-func (pq *priorityQueue) peek() any {
-	queue := *pq
-	n := len(queue)
-	return queue[n-1]
-}
-
-func (pq *priorityQueue) update(item *priorQueueItem, value *nfaState, priority int) {
-	item.state = value
-	item.priority = priority
-	heap.Fix(pq, item.index)
-}

regex/range2regex.go

@@ -109,7 +109,7 @@ func range2regex(start int, end int) (string, error) {
 		startSlc := intToSlc(rg.start)
 		endSlc := intToSlc(rg.end)
 		if len(startSlc) != len(endSlc) {
-			return "", fmt.Errorf("Error parsing numeric range")
+			return "", fmt.Errorf("error parsing numeric range")
 		}
 		for i := range startSlc {
 			if startSlc[i] == endSlc[i] {

regex/re_test.go

@@ -25,7 +25,9 @@ var reTests = []struct {
 	{"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}}},
+	// This match will only happen with Longest()
+	// {"(abc)*|(def)*", nil, "abcdef", []Group{{0, 3}, {3, 6}, {6, 6}}},
+	{"(abc)*|(def)*", nil, "abcdef", []Group{{0, 3}, {3, 3}, {4, 4}, {5, 5}, {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}}},
@@ -115,6 +117,7 @@ var reTests = []struct {
 	{`\d{3,4}`, nil, "ababab555", []Group{{6, 9}}},
 	{`\bpaint\b`, nil, "paints", []Group{}},
 	{`\b\w{5}\b`, nil, "paint", []Group{{0, 5}}},
+	{`\w{}`, nil, "test", nil},
 	{`[^\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}}},
@@ -177,7 +180,7 @@ var reTests = []struct {
 	{"[[:graph:]]+", nil, "abcdefghijklmnopqrstuvwyxzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789!@#$%^&*", []Group{{0, 70}}},
 
 	// Test cases from Python's RE test suite
-	{`[\1]`, nil, "\x01", []Group{{0, 1}}},
+	{`[\01]`, nil, "\x01", []Group{{0, 1}}},
 
 	{`\0`, nil, "\x00", []Group{{0, 1}}},
 	{`[\0a]`, nil, "\x00", []Group{{0, 1}}},
@@ -192,7 +195,7 @@ var reTests = []struct {
 	{`\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}}},
+	{`^\w+=(\\[\000-\0277]|[^\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{}},
@@ -310,11 +313,7 @@ var reTests = []struct {
 	{`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.
+	{`\0141`, nil, "a", []Group{{0, 1}}},
 
 	{`*a`, nil, ``, nil},
 	{`(*)b`, nil, ``, nil},
@@ -431,7 +430,8 @@ var reTests = []struct {
 	{`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}}},
+	{`\0141`, []ReFlag{RE_CASE_INSENSITIVE}, "A", []Group{{0, 1}}},
+	{`\0141\0141`, []ReFlag{RE_CASE_INSENSITIVE}, "AA", []Group{{0, 2}}},
 
 	{`a[-]?c`, []ReFlag{RE_CASE_INSENSITIVE}, `AC`, []Group{{0, 2}}},
 
@@ -462,8 +462,10 @@ var reTests = []struct {
 	{`[\D5]+`, nil, `1234abc5678`, []Group{{4, 8}}},
 	{`[\da-fA-F]+`, nil, `123abc`, []Group{{0, 6}}},
 	{`\xff`, nil, "\u00ff", []Group{{0, 1}}},
+	{`\xff+`, nil, "\u00ff\u00ff", []Group{{0, 2}}},
 	{`\xFF`, nil, "\u00ff", []Group{{0, 1}}},
 	{`\x00ff`, nil, "\u00ff", []Group{}},
+	{`\x{0000ff}+`, nil, "\u00ff\u00ff", []Group{{0, 2}}},
 	{`\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}}},
@@ -471,7 +473,7 @@ var reTests = []struct {
 	{`[\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}}},
+	{`[\041]`, 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}}},
@@ -487,7 +489,25 @@ var reTests = []struct {
 	{`[b-e]`, nil, `f`, []Group{}},
 
 	{`*?`, nil, `-`, nil},
-	{`a*?`, nil, `-`, nil}, // non-greedy operators are not supported
+	{`a.+c`, nil, `abcabc`, []Group{{0, 6}}},
+	// Lazy quantifier tests
+	{`a.+?c`, nil, `abcabc`, []Group{{0, 3}, {3, 6}}},
+	{`ab*?bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBBBC`, []Group{{0, 6}}},
+	{`ab+?bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBC`, []Group{{0, 4}}},
+	{`ab??bc`, []ReFlag{RE_CASE_INSENSITIVE}, `ABBC`, []Group{{0, 4}}},
+	{`ab??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}}},
+	{`a.*?c`, []ReFlag{RE_CASE_INSENSITIVE}, `AXYZC`, []Group{{0, 5}}},
+	{`a.+?c`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCABC`, []Group{{0, 3}, {3, 6}}},
+	{`a.*?c`, []ReFlag{RE_CASE_INSENSITIVE}, `ABCABC`, []Group{{0, 3}, {3, 6}}},
+	{`.*?\S *:`, nil, `xx:`, []Group{{0, 3}}},
+	{`a[ ]*? (\d+).*`, nil, `a   10`, []Group{{0, 6}}},
+	{`a[ ]*? (\d+).*`, nil, `a    10`, []Group{{0, 7}}},
+	{`"(?:\\"|[^"])*?"`, nil, `"\""`, []Group{{0, 4}}},
+	{`^.*?$`, nil, "one\ntwo\nthree", []Group{}},
+	{`a[^>]*?b`, nil, `a>b`, []Group{}},
+	{`^a*?$`, nil, `foo`, []Group{}},
 
 	// Numeric range tests - this is a feature that I added, and doesn't exist
 	// in any other mainstream regex engine
@@ -518,6 +538,30 @@ var reTests = []struct {
 	{`<389-400`, nil, `-`, nil},
 	{`<389-400>`, nil, `391`, []Group{{0, 3}}},
 	{`\b<1-10000>\b`, nil, `America declared independence in 1776.`, []Group{{33, 37}}},
+
+	{`\p{Tamil}+`, nil, `உயிரெழுத்து`, []Group{{0, 11}}}, // Each letter and matra is counted as a separate rune, so 'u', 'ya', 'e (matra), 'ra', 'e (matra)', 'zha', (oo (matra), 'tha', 'ith', 'tha', 'oo (matra)'.
+	{`\P{Tamil}+`, nil, `vowel=உயிரெழுத்து`, []Group{{0, 6}}},
+	{`\P`, nil, `உயிரெழுத்து`, nil},
+	{`\PM\pM*`, nil, `உயிரெழுத்து`, []Group{{0, 1}, {1, 3}, {3, 5}, {5, 7}, {7, 9}, {9, 11}}},
+	{`\pN+`, nil, `123abc456def`, []Group{{0, 3}, {6, 9}}},
+	{`\PN+`, nil, `123abc456def`, []Group{{3, 6}, {9, 12}}},
+	{`[\p{Greek}\p{Cyrillic}]`, nil, `ΣωШД`, []Group{{0, 1}, {1, 2}, {2, 3}, {3, 4}}},
+
+	{`(?<=\().*?(?=\))`, nil, `(abc)`, []Group{{1, 4}}},
+
+	{`((a|b)\2)`, nil, `aa`, []Group{{0, 2}}},
+	{`((a|b)\2)`, nil, `bb`, []Group{{0, 2}}},
+	{`((a|b)\2)`, nil, `ab`, []Group{}},
+	{`((a|b)\2)`, nil, `ba`, []Group{}},
+
+	{`((a|b)\2){3}`, nil, `aaaaaa`, []Group{{0, 6}}},
+	{`((a|b)\2){3}`, nil, `bbbbbb`, []Group{{0, 6}}},
+	{`((a|b)\2){3}`, nil, `bbaaaa`, []Group{{0, 6}}},
+	{`((a|b)\2){3}`, nil, `aabbaa`, []Group{{0, 6}}},
+	{`((a|b)\2){3}`, nil, `aaaabb`, []Group{{0, 6}}},
+	{`((a|b)\2){3}`, nil, `bbaabb`, []Group{{0, 6}}},
+	{`((a|b)\2){3}`, nil, `baabab`, []Group{}},
+	{`((a|b)\2){3}`, nil, `bbabab`, []Group{}},
 }
 
 var groupTests = []struct {
@@ -528,7 +572,7 @@ var groupTests = []struct {
 }{
 	{"(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{}}},
+	{"(0)", nil, "ab", []Match{}},
 	{"(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}}}},
@@ -537,10 +581,11 @@ var groupTests = []struct {
 	{"(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}}}},
+	// This match will only happen with Longest()
+	//	{"(aaa)|(aaaa)", nil, "aaaa", []Match{[]Group{{0, 4}, {-1, -1}, {0, 4}}}},
+	{"(aaa)|(aaaa)", nil, "aaaa", []Match{[]Group{{0, 3}, {0, 3}, {-1, -1}}}},
 	{"(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)|(aa)", nil, "aa", []Match{[]Group{{0, 1}, {0, 1}}, []Group{{1, 2}, {1, 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}}}},
@@ -578,13 +623,37 @@ var groupTests = []struct {
 	{`(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}}}},
+	{`(((((((((a)))))))))\041`, 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.
+	// Backreference tests
+	{`(abc)\1`, nil, `abcabc`, []Match{[]Group{{0, 6}, {0, 3}}}},
+	{`([a-c]+)\1`, nil, `abcabc`, []Match{[]Group{{0, 6}, {0, 3}}}},
+	{`([a-c]*)\1`, nil, `abcabc`, []Match{[]Group{{0, 6}, {0, 3}}, []Group{{6, 6}, {6, 6}}}},
+	{`^(.+)?B`, nil, `AB`, []Match{[]Group{{0, 2}, {0, 1}}}},
+	{`(a+).\1$`, nil, `aaaaa`, []Match{[]Group{{0, 5}, {0, 2}}}},
+	{`^(a+).\1$`, nil, `aaaa`, []Match{}},
+	{`(a)\1`, nil, `aa`, []Match{[]Group{{0, 2}, {0, 1}}}},
+	{`(a+)\1`, nil, `aa`, []Match{[]Group{{0, 2}, {0, 1}}}},
+	{`(a+)+\1`, nil, `aa`, []Match{[]Group{{0, 2}, {0, 1}}}},
+	{`(a).+\1`, nil, `aba`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`(a)ba*\1`, nil, `aba`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`(aa|a)a\1$`, nil, `aaa`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`(a|aa)a\1$`, nil, `aaa`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`(a+)a\1$`, nil, `aaa`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`([abc]*)\1`, nil, `abcabc`, []Match{[]Group{{0, 6}, {0, 3}}, []Group{{6, 6}, {6, 6}}}},
+	{`(a)(?:b)\1`, nil, `aba`, []Match{[]Group{{0, 3}, {0, 1}}}},
+	{`(a)(?:b)\1`, nil, `abb`, []Match{}},
+	{`(?:a)(b)\1`, nil, `aba`, []Match{}},
+	{`(?:a)(b)\1`, nil, `abb`, []Match{[]Group{{0, 3}, {1, 2}}}},
+	{`(?:(cat)|(dog))\2`, nil, `catdog`, []Match{}},
+	{`(?:a)\1`, nil, `aa`, nil},
+	{`((cat)|(dog)|(cow)|(bat))\4`, nil, `cowcow`, []Match{[]Group{{0, 6}, {0, 3}, {-1, -1}, {-1, -1}, {0, 3}, {-1, -1}}}},
+	{`(a|b)*\1`, nil, `abb`, []Match{[]Group{{0, 3}, {1, 2}}}},
+	{`(a|b)*\1`, nil, `aba`, []Match{}},
+	{`(a|b)*\1`, nil, `bab`, []Match{}},
+	{`(a|b)*\1`, nil, `baa`, []Match{[]Group{{0, 3}, {1, 2}}}},
 
 	{`(a)(b)c|ab`, nil, `ab`, []Match{[]Group{{0, 2}}}},
 	{`(a)+x`, nil, `aaax`, []Match{[]Group{{0, 4}, {2, 3}}}},
@@ -633,7 +702,7 @@ var groupTests = []struct {
 	{`(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}}}},
+	{`(((((((((a)))))))))\041`, []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}}}},
@@ -685,6 +754,18 @@ var groupTests = []struct {
 	// {`(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}}}},
+
+	// Lazy quantifier tests
+	{`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}}}},
+	{`.*?x\s*\z(.*)`, []ReFlag{RE_MULTILINE, RE_SINGLE_LINE}, "xx\nx\n", []Match{[]Group{{0, 5}, {5, 5}}}},
+	{`.*?x\s*\z(.*)`, []ReFlag{RE_MULTILINE}, "xx\nx\n", []Match{[]Group{{3, 5}, {5, 5}}}},
+	{`^([ab]*?)(?=(b)?)c`, nil, `abc`, []Match{[]Group{{0, 3}, {0, 2}, {-1, -1}}}},
+	{`^([ab]*?)(?!(b))c`, nil, `abc`, []Match{[]Group{{0, 3}, {0, 2}, {-1, -1}}}},
+	{`^([ab]*?)(?<!(a))c`, nil, `abc`, []Match{[]Group{{0, 3}, {0, 2}, {-1, -1}}}},
 }
 
 func TestFind(t *testing.T) {
@@ -743,7 +824,7 @@ func TestFindString(t *testing.T) {
 				foundString := regComp.FindString(test.str)
 				if len(test.result) == 0 {
 					if foundString != "" {
-						t.Errorf("Expected no match got %v\n", foundString)
+						t.Errorf("Wanted no match got %v\n", foundString)
 					}
 				} else {
 					expectedString := test.str[test.result[0].StartIdx:test.result[0].EndIdx]
@@ -789,18 +870,132 @@ func TestFindSubmatch(t *testing.T) {
 				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)
+			} else {
+				match, err := regComp.FindSubmatch(test.str)
+				if err != nil {
+					if len(test.result) != 0 {
+						t.Errorf("Wanted %v got no match\n", test.result[0])
+					}
+				} else if len(test.result) == 0 {
+					t.Errorf("Wanted no match got %v\n", match)
+				}
+				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)
+						}
+					} else {
+						if i < len(test.result) && test.result[0][i].IsValid() {
+							t.Errorf("Wanted %v	Got %v\n", test.result[0], match)
+						}
 					}
 				}
 			}
 		})
 	}
 }
+func TestFindStringSubmatch(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)
+				}
+			} else {
+				matchStr := regComp.FindStringSubmatch(test.str)
+				if matchStr == nil {
+					if len(test.result) != 0 {
+						expectedStr := funcMap(test.result[0], func(g Group) string {
+							if g.IsValid() {
+								return test.str[g.StartIdx:g.EndIdx]
+							} else {
+								return ""
+							}
+						})
+						t.Errorf("Wanted %v got no match\n", expectedStr)
+					}
+				} else if len(test.result) == 0 {
+					t.Errorf("Wanted no match got %v\n", matchStr)
+				} else {
+					expectedStr := funcMap(test.result[0], func(g Group) string {
+						if g.IsValid() {
+							return test.str[g.StartIdx:g.EndIdx]
+						} else {
+							return ""
+						}
+					})
+					for i, groupStr := range matchStr {
+						if groupStr == "" {
+							if i < len(expectedStr) && expectedStr[i] != "" {
+								t.Errorf("Wanted %v	Got %v\n", expectedStr, matchStr)
+							}
+						} else {
+							if expectedStr[i] != groupStr {
+								t.Errorf("Wanted %v	Got %v\n", expectedStr, matchStr)
+							}
+						}
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestFindAllStringSubmatch(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)
+				}
+			} else {
+				matchStrs := regComp.FindAllStringSubmatch(test.str)
+				if matchStrs == nil {
+					if len(test.result) != 0 {
+						expectedStrs := funcMap(test.result, func(m Match) []string {
+							return funcMap(m, func(g Group) string {
+								if g.IsValid() {
+									return test.str[g.StartIdx:g.EndIdx]
+								} else {
+									return ""
+								}
+							})
+						})
+						t.Errorf("Wanted %v got no match\n", expectedStrs)
+					}
+				} else if len(test.result) == 0 {
+					t.Errorf("Wanted no match got %v\n", matchStrs)
+				} else {
+					expectedStrs := funcMap(test.result, func(m Match) []string {
+						return funcMap(m, func(g Group) string {
+							if g.IsValid() {
+								return test.str[g.StartIdx:g.EndIdx]
+							} else {
+								return ""
+							}
+						})
+					})
+					for i, matchStr := range matchStrs {
+						for j, groupStr := range matchStr {
+							if groupStr == "" {
+								if j < len(expectedStrs[i]) && expectedStrs[i][j] != "" {
+									t.Errorf("Wanted %v	Got %v\n", expectedStrs, matchStrs)
+								}
+							} else {
+								if expectedStrs[i][j] != groupStr {
+									t.Errorf("Wanted %v	Got %v\n", expectedStrs, matchStrs)
+								}
+							}
+						}
+					}
+				}
+			}
+		})
+	}
+}
+
 func TestFindAllSubmatch(t *testing.T) {
 	for _, test := range groupTests {
 		t.Run(test.re+"	"+test.str, func(t *testing.T) {
@@ -809,13 +1004,18 @@ func TestFindAllSubmatch(t *testing.T) {
 				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)
+			} else {
+				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)
+							}
+						} else {
+							if i < len(test.result) && j < len(test.result[i]) && test.result[i][j].IsValid() {
+								t.Errorf("Wanted %v	Got %v\n", test.result, matchIndices)
+							}
 						}
 					}
 				}

regex/todo.txt

@@ -4,4 +4,5 @@
 Ideas for flags:
     -m <num> : Print <num>th match (-m 1 = first match, -m 2 = second match)
     -g <num> : Print the <num>th group
+    -r : Specify a directory instead of a file, reads recursively
 4. Refactor code for flags - make each flag's code a function, which modifies the result of findAllMatches