Reuse the executor in firstMatch

Sources/_StringProcessing/Engine/Processor.swift

@@ -32,7 +32,7 @@ struct Processor<
   typealias Element = Input.Element
 
   let input: Input
-  let bounds: Range<Position>
+  var bounds: Range<Position>
   let matchMode: MatchMode
   var currentPosition: Position
 
@@ -94,6 +94,23 @@ extension Processor {
     assert(currentPosition >= start)
     assert(currentPosition <= end)
   }
+
+  mutating func reset(newBounds: Range<Position>)
+  {
+    self.bounds = newBounds
+
+    self.controller = Controller(pc: 0)
+    self.currentPosition = bounds.lowerBound
+
+    self.registers.reset(bounds.upperBound)
+    self.storedCaptures = self.storedCaptures.map {_ in .init()}
+
+    self.cycleCount = 0
+    self.savePoints = []
+    self.callStack = []
+    self.state = .inProgress
+    self.failureReason = nil
+  }
 }
 
 extension Processor {

Sources/_StringProcessing/Engine/Registers.swift

@@ -18,6 +18,8 @@ struct SentinelValue: Hashable, CustomStringConvertible {
 extension Processor {
   /// Our register file
   struct Registers {
+    var info: MEProgram<Input>.RegisterInfo
+
     // currently, these are static readonly
     var elements: [Element]
 
@@ -114,7 +116,7 @@ extension Processor.Registers {
     _ program: MEProgram<Input>,
     _ sentinel: Input.Index
   ) {
-    let info = program.registerInfo
+    self.info = program.registerInfo
 
     self.elements = program.staticElements
     assert(elements.count == info.elements)
@@ -156,6 +158,22 @@ extension Processor.Registers {
 
     self.savePointAddresses = Array(repeating: 0, count: info.savePointAddresses)
   }
+
+  mutating func reset(_ sentinel: Input.Index) {
+    // note: Is there any issue with the program transform functions holding
+    // state and not getting reset here? Do we care?
+    self.bools = Array(repeating: false, count: info.bools)
+    self.ints = Array(repeating: 0, count: info.ints)
+    self.floats = Array(repeating: 0, count: info.floats)
+    self.positions = Array(repeating: sentinel, count: info.positions)
+    self.values = Array(
+      repeating: SentinelValue(), count: info.values)
+
+    self.instructionAddresses = Array(repeating: 0, count: info.instructionAddresses)
+    self.classStackAddresses = Array(repeating: 0, count: info.classStackAddresses)
+    self.positionStackAddresses = Array(repeating: 0, count: info.positionStackAddresses)
+    self.savePointAddresses = Array(repeating: 0, count: info.savePointAddresses)
+  }
 }
 
 extension MEProgram {

Sources/_StringProcessing/Executor.swift

@@ -27,7 +27,42 @@ struct Executor {
   ) throws -> Regex<Output>.Match? {
     var cpu = engine.makeProcessor(
       input: input, bounds: inputRange, matchMode: mode)
+    return try consume(input, &cpu)
+  }
+
+  @available(SwiftStdlib 5.7, *)
+  func firstMatch<Output>(
+    _ input: String,
+    in inputRange: Range<String.Index>,
+    level: MatchingOptions.SemanticLevel
+  ) throws -> Regex<Output>.Match? {
+    var low = inputRange.lowerBound
+    let high = inputRange.upperBound
+    let mode: MatchMode = .partialFromFront
+    var cpu = engine.makeProcessor(
+      input: input, bounds: inputRange, matchMode: mode)
+
+    while true {
+      if let m: Regex<Output>.Match = try consume(input, &cpu) {
+        return m
+      }
+
+      if low >= high { return nil }
+      if level == .graphemeCluster {
+        input.formIndex(after: &low)
+      } else {
+        input.unicodeScalars.formIndex(after: &low)
+      }
 
+      cpu.reset(newBounds: low..<high)
+    }
+  }
+
+  @available(SwiftStdlib 5.7, *)
+  func consume<Output>(
+    _ input: String,
+    _ cpu: inout Processor<String>
+  ) throws -> Regex<Output>.Match? {
     guard let endIdx = cpu.consume() else {
       if let e = cpu.failureReason {
         throw e
@@ -40,7 +75,7 @@ struct Executor {
       referencedCaptureOffsets: engine.program.referencedCaptureOffsets,
       namedCaptureOffsets: engine.program.namedCaptureOffsets)
 
-    let range = inputRange.lowerBound..<endIdx
+    let range = cpu.bounds.lowerBound..<endIdx
     let caps = engine.program.captureList.createElements(capList, input)
 
     // FIXME: This is a workaround for not tracking (or

Sources/_StringProcessing/Regex/Match.swift

@@ -151,22 +151,11 @@ extension Regex {
     _ input: String,
     in inputRange: Range<String.Index>
   ) throws -> Regex<Output>.Match? {
-    // FIXME: Something more efficient, likely an engine interface, and we
-    // should scrap the RegexConsumer crap and call this
-
-    var low = inputRange.lowerBound
-    let high = inputRange.upperBound
-    while true {
-      if let m = try _match(input, in: low..<high, mode: .partialFromFront) {
-        return m
-      }
-      if low >= high { return nil }
-      if regex.initialOptions.semanticLevel == .graphemeCluster {
-        input.formIndex(after: &low)
-      } else {
-        input.unicodeScalars.formIndex(after: &low)
-      }
-    }
+    let executor = Executor(program: regex.program.loweredProgram)
+    return try executor.firstMatch(
+      input, in: inputRange,
+      level: regex.initialOptions.semanticLevel
+    )
   }
 }