Backend foundations of captures and back references

No compiler support just yet

Author: milseman

Sources/_MatchingEngine/Engine/Builder.swift

@@ -14,6 +14,7 @@ extension Program where Input.Element: Hashable {
     // Registers
     var nextBoolRegister = BoolRegister(0)
     var nextIntRegister = IntRegister(0)
+    var nextPositionRegister = PositionRegister(0)
 
     // Special addresses or instructions
     var failAddressToken: AddressToken? = nil
@@ -73,6 +74,13 @@ extension Program.Builder {
     buildMoveImmediate(uint, into: into)
   }
 
+  public mutating func buildMoveCurrentPosition(
+    into: PositionRegister
+  ) {
+    instructions.append(.init(
+      .movePosition, .init(position: into)))
+  }
+
   public mutating func buildBranch(to t: AddressToken) {
     instructions.append(.init(.branch))
     fixup(to: t)
@@ -150,6 +158,14 @@ extension Program.Builder {
       .init(sequence: sequences.store(.init(s)))))
   }
 
+  public mutating func buildMatchSlice(
+    lower: PositionRegister, upper: PositionRegister
+  ) {
+    instructions.append(.init(
+      .matchSlice,
+      .init(pos: lower, pos2: upper)))
+  }
+
   public mutating func buildConsume(
     by p: @escaping Program.ConsumeFunction
   ) {
@@ -225,6 +241,7 @@ extension Program.Builder {
     regInfo.strings = strings.count
     regInfo.bools = nextBoolRegister.rawValue
     regInfo.ints = nextIntRegister.rawValue
+    regInfo.positions = nextPositionRegister.rawValue
     regInfo.consumeFunctions = consumeFunctions.count
 
     return Program(
@@ -311,6 +328,10 @@ extension Program.Builder {
     defer { nextIntRegister.rawValue += 1 }
     return nextIntRegister
   }
+  public mutating func makePositionRegister() -> PositionRegister {
+    defer { nextPositionRegister.rawValue += 1 }
+    return nextPositionRegister
+  }
 
   // Allocate and initialize a register
   public mutating func makeIntRegister(
@@ -321,6 +342,15 @@ extension Program.Builder {
     return r
   }
 
+  // Allocate and initialize a register
+  public mutating func makePositionRegister(
+    initializingWithCurrentPosition: ()
+  ) -> PositionRegister {
+    let r = makePositionRegister()
+    self.buildMoveCurrentPosition(into: r)
+    return r
+  }
+
   // 'kill' or release allocated registers
   public mutating func kill(_ r: IntRegister) {
     // TODO: Release/reuse registers, for now nop makes
@@ -332,15 +362,20 @@ extension Program.Builder {
     // reading the code easier
     buildNop("kill \(r)")
   }
+  public mutating func kill(_ r: PositionRegister) {
+    // TODO: Release/reuse registers, for now nop makes
+    // reading the code easier
+    buildNop("kill \(r)")
+  }
+
+  // TODO: A register-mapping helper struct, which could release
+  // registers without monotonicity required
 
   public mutating func makeConsumeFunction(
     _ f: @escaping Program.ConsumeFunction
   ) -> ConsumeFunctionRegister {
     defer { consumeFunctions.append(f) }
     return ConsumeFunctionRegister(consumeFunctions.count)
   }
-
-  // TODO: consider releasing registers
-
 }
 

Sources/_MatchingEngine/Engine/InstPayload.swift

@@ -32,6 +32,7 @@ extension Instruction.Payload {
 
     case string(StringRegister)
     case sequence(SequenceRegister)
+    case position(PositionRegister)
     case optionalString(StringRegister?)
     case int(IntRegister)
     case distance(Distance)
@@ -46,6 +47,7 @@ extension Instruction.Payload {
     case packedAddrAddr(InstructionAddress, InstructionAddress)
     case packedBoolInt(BoolRegister, IntRegister)
     case packedEltBool(ElementRegister, BoolRegister)
+    case packedPosPos(PositionRegister, PositionRegister)
   }
 }
 
@@ -142,6 +144,13 @@ extension Instruction.Payload {
     interpret()
   }
 
+  init(position: PositionRegister) {
+    self.init(position)
+  }
+  var position: PositionRegister {
+    interpret()
+  }
+
   init(int: IntRegister) {
     self.init(int)
   }
@@ -236,5 +245,12 @@ extension Instruction.Payload {
     interpretPair()
   }
 
+  init(pos: PositionRegister, pos2: PositionRegister) {
+    self.init(pos, pos2)
+  }
+  var pairedPosPos: (PositionRegister, PositionRegister) {
+    interpretPair()
+  }
+
 }
 

Sources/_MatchingEngine/Engine/Instruction.swift

@@ -20,8 +20,7 @@ extension Instruction {
     ///
     ///     nop(comment: String?)
     ///
-    /// Operand:
-    ///   - Optional string register containing a comment or reason
+    /// Operand: Optional string register containing a comment or reason
     ///
     case nop
 
@@ -41,29 +40,37 @@ extension Instruction {
     ///     moveImmediate(_ i: Int, into: IntReg)
     ///
     /// Operands:
-    ///   - TODO
+    ///   - Immediate value to move
+    ///   - Int register to move into
     ///
     case moveImmediate
 
     // MARK: General Purpose: Control flow
 
     /// Branch to a new instruction
     ///
+    ///     branch(to: InstAddr)
+    ///
     /// Operand: instruction address to branch to
     case branch
 
     /// Conditionally branch
     ///
-    /// Operand: packed condition register and address to branch to
+    ///     condBranch(to: InstAddr, if: BoolReg)
+    ///
+    /// Operands:
+    ///   - Address to branch to
+    ///   - Condition register to check
     case condBranch
 
     /// Conditionally branch if zero, otherwise decrement
     ///
-    ///     branch_cond_zero_else_decrement(_ i: IntReg, to: InstructionAddress)
+    ///     condBranch(
+    ///       to: InstAddr, ifZeroElseDecrement: IntReg)
     ///
     /// Operands:
-    ///   - Int register to check for zero, otherwise decrease
     ///   - Instruction address to branch to, if zero
+    ///   - Int register to check for zero, otherwise decrease
     ///
     case condBranchZeroElseDecrement
 
@@ -101,26 +108,48 @@ extension Instruction {
     case print
 
 
-
     // MARK: - Matching
 
     /// Advance the input position.
     ///
+    ///     advance(_ amount: Distance)
+    ///
     /// Operand: Amount to advance by.
     case advance
 
     // TODO: Is the amount useful here? Is it commonly more than 1?
 
     /// Composite assert-advance else restore.
     ///
+    ///     match(_: EltReg)
+    ///
     /// Operand: Element register to compare against.
     case match
 
     /// Match against a sequence of elements
     ///
+    ///     matchSequence(_: SeqReg)
+    ///
     /// Operand: Sequence register to compare against.
     case matchSequence
 
+    /// Match against a slice of the input
+    ///
+    ///     matchSlice(
+    ///       lowerBound: PositionReg, upperBound: PositionReg)
+    ///
+    /// Operands:
+    ///   - Lowerbound position in the input
+    ///   - Upperbound position in the input
+    case matchSlice
+
+    /// Save the current position in the input in a register
+    ///
+    ///     movePosition(into: PositionReg)
+    ///
+    /// Operand: The position register to move into
+    case movePosition
+
     /// Match against a provided element.
     ///
     /// Operand: Packed condition register to write to and element register to

Sources/_MatchingEngine/Engine/Processor.swift

@@ -133,6 +133,32 @@ extension Processor {
     return slice
   }
 
+  mutating func match(_ e: Element) {
+    guard let cur = load(), cur == e else {
+      signalFailure()
+      return
+    }
+    if consume(1) {
+      controller.step()
+    }
+  }
+  mutating func matchSeq<C: Collection>(
+    _ seq: C
+  ) where C.Element == Input.Element {
+    let count = seq.count
+
+    guard let inputSlice = load(count: count),
+          seq.elementsEqual(inputSlice)
+    else {
+      signalFailure()
+      return
+    }
+    guard consume(.init(count)) else {
+      fatalError("unreachable")
+    }
+    controller.step()
+  }
+
   mutating func signalFailure() {
     guard let (pc, pos, stackEnd) = savePoints.popLast()?.destructure
     else {
@@ -197,6 +223,11 @@ extension Processor {
       registers[reg] = int
       controller.step()
 
+    case .movePosition:
+      let reg = payload.position
+      registers[reg] = currentPosition
+      controller.step()
+
     case .branch:
       controller.pc = payload.addr
 
@@ -291,29 +322,18 @@ extension Processor {
 
     case .match:
       let reg = payload.element
-      guard let cur = load(), cur == registers[reg] else {
-        signalFailure()
-        return
-      }
-      if consume(1) {
-        controller.step()
-      }
+      match(registers[reg])
 
     case .matchSequence:
       let reg = payload.sequence
       let seq = registers[reg]
-      let count = seq.count
+      matchSeq(seq)
 
-      guard let inputSlice = load(count: count),
-            seq.elementsEqual(inputSlice)
-      else {
-        signalFailure()
-        return
-      }
-      guard consume(.init(count)) else {
-        fatalError("unreachable")
-      }
-      controller.step()
+    case .matchSlice:
+      let (lower, upper) = payload.pairedPosPos
+      let range = registers[lower]..<registers[upper]
+      let slice = input[range]
+      matchSeq(slice)
 
     case .consumeBy:
       let reg = payload.consumer

Sources/_MatchingEngine/Engine/Registers.swift

@@ -24,10 +24,7 @@ extension Processor {
     // unused
     var floats: [Double] = []
 
-    // unused
-    //
-    // Unlikely to be static, as that means input must be bound
-    // at compile time
+    // Currently, used for `movePosition` and `matchSlice`
     var positions: [Position] = []
 
     // unused
@@ -56,6 +53,10 @@ extension Processor {
       get { bools[i.rawValue] }
       set { bools[i.rawValue] = newValue }
     }
+    subscript(_ i: PositionRegister) -> Position {
+      get { positions[i.rawValue] }
+      set { positions[i.rawValue] = newValue }
+    }
     subscript(_ i: ElementRegister) -> Element {
       elements[i.rawValue]
     }

Tests/MatchingEngineTests/MatchingEngineTests.swift

@@ -226,6 +226,8 @@ let eatThroughA: Engine<String> = {
   }
 }()
 
+
+
 class MatchingEngineTests: XCTestCase {
 
   func testAEaters() {
@@ -247,4 +249,42 @@ class MatchingEngineTests: XCTestCase {
       test.check(eatThroughA: eatThroughA)
     }
   }
+
+  func testThreeLetterRepeat() {
+    // Check for a repeated 3-letter sequence, such as in
+    //   `(...)\1`
+    //
+    //   [0] movePosition(into: %low)
+    //   [1] advance(3)
+    //   [2] movePosition(into: %high)
+    //   [3] matchSlice(%low, %high)
+    //   [4] accept
+    let threeLetterRepeat: Engine<String> = {
+      makeEngine { builder in
+        let low = builder.makePositionRegister(
+          initializingWithCurrentPosition: ())
+        builder.buildAdvance(3)
+        let high = builder.makePositionRegister(
+          initializingWithCurrentPosition: ())
+        builder.buildMatchSlice(lower: low, upper: high)
+        builder.buildAccept()
+      }
+    }()
+
+    let tests: Array<(String, Bool)> = [
+      ("abcabc", true),
+      ("abcabc_____", true),
+      ("dddddd_____", true),
+      ("🥳🧟‍♀️c🥳🧟‍♀️c", true),
+      ("abccba", false),
+      ("abcabb", false),
+      ("abcbac", false),
+      ("🥳🧟‍♀️c🥳🧟‍♂️c", false),
+    ]
+
+    for (test, expect) in tests {
+      let match = threeLetterRepeat.consume(test) != nil
+      XCTAssertEqual(expect, match)
+    }
+  }
 }