Added code to match capturing groups and store into a Group (used to be MatchIndex)

matching.go

@@ -5,74 +5,133 @@ import (
 	"sort"
 )
 
-// a MatchIndex represents a match/group. It contains the start index and end index of the match
-type MatchIndex struct {
+// a Match stores a slice of all the capturing groups in a match.
+type Match []Group
+
+// a Group represents a group. It contains the start index and end index of the match
+type Group struct {
 	startIdx int
 	endIdx   int
 }
 
-// Converts the MatchIndex into a string representation:
-func (idx MatchIndex) toString() string {
+func newMatch(size int) Match {
+	toRet := make([]Group, size)
+	for i := range toRet {
+		toRet[i].startIdx = -1
+		toRet[i].endIdx = -1
+	}
+	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) toString() string {
+	var toRet string
+	for i, g := range m {
+		if g.isValid() {
+			toRet += fmt.Sprintf("Group %d\n", i)
+			toRet += g.toString()
+			toRet += "\n"
+		}
+	}
+	return toRet
+}
+
+// Converts the Group into a string representation:
+func (idx Group) toString() string {
 	return fmt.Sprintf("%d\t%d", idx.startIdx, idx.endIdx)
 }
 
+// Returns whether a group contains valid indices
+func (g Group) isValid() bool {
+	return g.startIdx >= 0 && g.endIdx >= 0
+}
+
 // takeZeroState takes the 0-state (if such a transition exists) for all states in the
 // given slice. It returns the resulting states. If any of the resulting states is a 0-state,
-// the second parameter is true.
-func takeZeroState(states []*State) (rtv []*State, isZero bool) {
+// the second ret val is true.
+// The third ret val is a list of all the group numbers of all the opening parentheses we crossed,
+// and the fourth is a list of all the closing parentheses we passed
+func takeZeroState(states []*State) (rtv []*State, isZero bool, openParenGroups []int, closeParenGroups []int) {
 	for _, state := range states {
 		if len(state.transitions[EPSILON]) > 0 {
+			for _, s := range state.transitions[EPSILON] {
+				if s.groupBegin {
+					openParenGroups = append(openParenGroups, s.groupNum)
+				}
+				if s.groupEnd {
+					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, true, openParenGroups, closeParenGroups
 		}
 	}
-	return rtv, false
+	return rtv, false, openParenGroups, closeParenGroups
 }
 
 // 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, states ...*State) bool {
-	zerostates, iszero := takeZeroState(states)
-	tempstates := make([]*State, 0, len(zerostates)+len(states))
+// It also returns all the capturing groups that both begin and end at the current index.
+// This is because, by definition, zero-states don't move forward in the string.
+func zeroMatchPossible(str []rune, idx int, states ...*State) (bool, []int, []int) {
+	allOpenParenGroups := make([]int, 0)
+	allCloseParenGroups := make([]int, 0)
+	zeroStates, isZero, openParenGroups, closeParenGroups := takeZeroState(states)
+	allOpenParenGroups = append(allOpenParenGroups, openParenGroups...)
+	allCloseParenGroups = append(allCloseParenGroups, closeParenGroups...)
+	tempstates := make([]*State, 0, len(zeroStates)+len(states))
 	tempstates = append(tempstates, states...)
-	tempstates = append(tempstates, zerostates...)
+	tempstates = append(tempstates, zeroStates...)
 	num_appended := 0 // number of unique states addded to tempstates
-	for iszero == true {
-		zerostates, iszero = takeZeroState(tempstates)
-		tempstates, num_appended = unique_append(tempstates, zerostates...)
+	for isZero == true {
+		zeroStates, isZero, openParenGroups, closeParenGroups = takeZeroState(tempstates)
+		allOpenParenGroups = append(allOpenParenGroups, openParenGroups...)
+		allCloseParenGroups = append(allCloseParenGroups, closeParenGroups...)
+		tempstates, num_appended = unique_append(tempstates, zeroStates...)
 		if num_appended == 0 { // break if we haven't appended any more unique values
 			break
 		}
 	}
 	for _, state := range tempstates {
 		if state.isEmpty && (state.assert == NONE || state.checkAssertion(str, idx)) && state.isLast {
-			return true
+			return true, allOpenParenGroups, allCloseParenGroups
 		}
 	}
-	return false
+	return false, allOpenParenGroups, allCloseParenGroups
 }
 
 // Prunes the slice by removing overlapping indices.
-func pruneIndices(indices []MatchIndex) []MatchIndex {
+func pruneIndices(indices []Match) []Match {
 	// First, sort the slice by the start indices
 	sort.Slice(indices, func(i, j int) bool {
-		return indices[i].startIdx < indices[j].startIdx
+		return indices[i][0].startIdx < indices[j][0].startIdx
 	})
-	toRet := make([]MatchIndex, 0, len(indices))
+	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.startIdx >= current.endIdx {
+		if idx[0].startIdx >= current[0].endIdx {
 			toRet = append(toRet, current)
 			current = idx
-		} else if idx.endIdx > current.endIdx {
+		} else if idx[0].endIdx > current[0].endIdx {
 			// idx overlaps, but it is longer, so update current
 			current = idx
 		}
@@ -84,46 +143,63 @@ func pruneIndices(indices []MatchIndex) []MatchIndex {
 
 // findAllMatches tries to find all matches of the regex represented by given start-state, with
 // the given string
-func findAllMatches(start *State, str []rune) []MatchIndex {
+func findAllMatches(start *State, str []rune, numGroups int) []Match {
 	idx := 0
 	var matchFound bool
-	var matchIdx MatchIndex
-	indices := new_uniq_arr[MatchIndex]()
+	var matchIdx Match
+	indices := make([]Match, 0)
 	for idx <= len(str) {
-		matchFound, matchIdx, idx = findAllMatchesHelper(start, str, idx)
+		matchFound, matchIdx, idx = findAllMatchesHelper(start, str, idx, numGroups)
 		if matchFound {
-			indices.add(matchIdx)
+			indices = append(indices, matchIdx)
 		}
 	}
-	toReturn := indices.values()
-	if len(toReturn) > 0 {
-		return pruneIndices(toReturn)
+	if len(indices) > 0 {
+		return pruneIndices(indices)
 	}
-	return toReturn
+	return indices
 }
 
 // Helper for findAllMatches. Returns whether it found a match, the
-// first matchIndex it finds, and how far it got into the string ie. where
+// 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 findAllMatchesHelper(start *State, str []rune, offset int) (bool, MatchIndex, int) {
+func findAllMatchesHelper(start *State, str []rune, offset int, numGroups int) (bool, Match, int) {
 	// Base case - exit if offset exceeds string's length
 	if offset > len(str) {
-		// The first value here shouldn't be used, because we should exit when the second return value is > than len(str)
-		return false, MatchIndex{}, offset
+		// The second value here shouldn't be used, because we should exit when the third return value is > than len(str)
+		return false, []Group{}, offset
 	}
 	// 'Base case' - if we are at the end of the string, check if we can add a zero-length match
 	if offset == len(str) {
 		// Get all zero-state matches. If we can get to a zero-state without matching anything, we
 		// can add a zero-length match. This is all true only if the start state itself matches nothing.
 		if start.isEmpty {
-			if zeroMatchPossible(str, offset, start) {
-				return true, MatchIndex{offset, offset}, offset + 1
+			to_return := newMatch(numGroups + 1)
+			if start.groupBegin {
+				to_return[start.groupNum].startIdx = offset
+			}
+			if ok, openGrps, closeGrps := zeroMatchPossible(str, offset, start); ok {
+				for _, gIdx := range openGrps {
+					to_return[gIdx].startIdx = offset
 				}
+				for _, gIdx := range closeGrps {
+					to_return[gIdx].endIdx = offset
 				}
-		return false, MatchIndex{}, offset + 1
+				to_return[0] = Group{offset, offset}
+				return true, to_return, offset + 1
 			}
+		}
+		return false, []Group{}, offset + 1
+	}
+
+	// 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
@@ -138,7 +214,7 @@ func findAllMatchesHelper(start *State, str []rune, offset int) (bool, MatchInde
 	if start.assert != NONE {
 		if start.checkAssertion(str, offset) == false {
 			i++
-			return false, MatchIndex{}, i
+			return false, []Group{}, i
 		}
 	}
 	// Increment until we hit a character matching the start state (assuming not 0-state)
@@ -150,13 +226,14 @@ func findAllMatchesHelper(start *State, str []rune, offset int) (bool, MatchInde
 		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
 	}
+
+	// Check if the start state begins a group - if so, add the start index to our list
+	if start.groupBegin {
+		tempIndices[start.groupNum].startIdx = i
+	}
+
 	currentStates = append(currentStates, 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).
-	tempIndices := make([]MatchIndex, 0)
 	// Main loop
 	for i < len(str) {
 		foundPath = false
@@ -164,11 +241,23 @@ func findAllMatchesHelper(start *State, str []rune, offset int) (bool, MatchInde
 		zeroStates := make([]*State, 0)
 		// Keep taking zero-states, until there are no more left to take
 		// Objective: If any of our current states have transitions to 0-states, replace them with the 0-state. Do this until there are no more transitions to 0-states, or there are no more unique 0-states to take.
-		zeroStates, isZero := takeZeroState(currentStates)
+		zeroStates, isZero, openParenGroups, closeParenGroups := takeZeroState(currentStates)
+		for _, val := range openParenGroups {
+			tempIndices[val].startIdx = i
+		}
+		for _, val := range closeParenGroups {
+			tempIndices[val].endIdx = i
+		}
 		tempStates = append(tempStates, zeroStates...)
 		num_appended := 0
 		for isZero == true {
-			zeroStates, isZero = takeZeroState(tempStates)
+			zeroStates, isZero, openParenGroups, closeParenGroups = takeZeroState(tempStates)
+			for _, val := range openParenGroups {
+				tempIndices[val].startIdx = i
+			}
+			for _, val := range closeParenGroups {
+				tempIndices[val].endIdx = i
+			}
 			tempStates, num_appended = unique_append(tempStates, zeroStates...)
 			if num_appended == 0 { // Break if we haven't appended any more unique values
 				break
@@ -217,18 +306,20 @@ func findAllMatchesHelper(start *State, str []rune, offset int) (bool, MatchInde
 				if i == startingFrom {
 					i++
 				}
-				return false, MatchIndex{}, i
+				return false, []Group{}, i
 			}
 		}
 		if lastStateInList { // A last-state was in the list of states. add the matchIndex to our MatchIndex list
 			endIdx = i
-			tempIndices, _ = unique_append(tempIndices, MatchIndex{startIdx, endIdx})
+			tempIndices[0] = Group{startIdx, endIdx}
 		}
 
 		// Check if we can find a zero-length match
 		if foundPath == false {
-			if zeroMatchPossible(str, i, currentStates...) {
-				tempIndices, _ = unique_append(tempIndices, MatchIndex{startIdx, startIdx})
+			if ok, _, _ := zeroMatchPossible(str, i, currentStates...); 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.
@@ -236,23 +327,14 @@ func findAllMatchesHelper(start *State, str []rune, offset int) (bool, MatchInde
 			startIdx++
 			//	i++
 			//			}
-			// Get the maximum index-range from the list
-			if len(tempIndices) > 0 {
-				indexToAdd := Reduce(tempIndices, func(i1 MatchIndex, i2 MatchIndex) MatchIndex {
-					r1 := i1.endIdx - i1.startIdx
-					r2 := i2.endIdx - i2.startIdx
-					if r1 >= r2 {
-						return i1
-					}
-					return i2
-				})
-				if indexToAdd.startIdx == indexToAdd.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, indexToAdd, indexToAdd.endIdx + 1
+			if tempIndices.numValidGroups() > 0 && tempIndices[0].isValid() {
+				if tempIndices[0].startIdx == tempIndices[0].endIdx { // If we have a zero-length match, we have to shift the index at which we start. Otherwise we keep looking at the same paert of the string over and over.
+					return true, tempIndices, tempIndices[0].endIdx + 1
 				} else {
-					return true, indexToAdd, indexToAdd.endIdx
+					return true, tempIndices, tempIndices[0].endIdx
 				}
 			}
-			return false, MatchIndex{}, startIdx
+			return false, []Group{}, startIdx
 		}
 		currentStates = make([]*State, len(tempStates))
 		copy(currentStates, tempStates)
@@ -263,11 +345,23 @@ func findAllMatchesHelper(start *State, str []rune, offset int) (bool, MatchInde
 
 	// 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.
-	zeroStates, isZero := takeZeroState(currentStates)
+	zeroStates, isZero, openParenGroups, closeParenGroups := takeZeroState(currentStates)
+	for _, val := range openParenGroups {
+		tempIndices[val].startIdx = i
+	}
+	for _, val := range closeParenGroups {
+		tempIndices[val].endIdx = i
+	}
 	tempStates = append(tempStates, zeroStates...)
 	num_appended := 0 // Number of unique states addded to tempStates
 	for isZero == true {
-		zeroStates, isZero = takeZeroState(tempStates)
+		zeroStates, isZero, openParenGroups, closeParenGroups = takeZeroState(tempStates)
+		for _, val := range openParenGroups {
+			tempIndices[val].startIdx = i
+		}
+		for _, val := range closeParenGroups {
+			tempIndices[val].endIdx = i
+		}
 		tempStates, num_appended = unique_append(tempStates, zeroStates...)
 		if num_appended == 0 { // Break if we haven't appended any more unique values
 			break
@@ -283,28 +377,20 @@ func findAllMatchesHelper(start *State, str []rune, offset int) (bool, MatchInde
 		if state.isLast && startIdx < len(str) {
 			if state.assert == NONE || state.checkAssertion(str, i) {
 				endIdx = i
-				tempIndices, _ = unique_append(tempIndices, MatchIndex{startIdx, endIdx})
+				tempIndices[0] = Group{startIdx, endIdx}
 			}
 		}
 	}
-	// Get the maximum index-range from the list
-	if len(tempIndices) > 0 {
-		indexToAdd := Reduce(tempIndices, func(i1 MatchIndex, i2 MatchIndex) MatchIndex {
-			r1 := i1.endIdx - i1.startIdx
-			r2 := i2.endIdx - i2.startIdx
-			if r1 >= r2 {
-				return i1
-			}
-			return i2
-		})
-		if indexToAdd.endIdx == indexToAdd.startIdx { // Same statement occurs above, see reasoning there
-			return true, indexToAdd, indexToAdd.endIdx + 1
+
+	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, indexToAdd, indexToAdd.endIdx
+			return true, tempIndices, tempIndices[0].endIdx
 		}
 	}
 	if startIdx == startingFrom { // Increment starting index if we haven't moved in the string. Prevents us from matching the same part of the string over and over.
 		startIdx++
 	}
-	return false, MatchIndex{}, startIdx
+	return false, []Group{}, startIdx
 }