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)
+ }
+ }
 }