Suppport quoted literal sequences

Author: milseman

Sources/_MatchingEngine/Engine/Builder.swift

@@ -3,6 +3,7 @@ extension Program where Input.Element: Hashable {
     var instructions: [Instruction] = []
 
     var elements = TypedSetVector<Input.Element, _ElementRegister>()
+    var sequences = TypedSetVector<[Input.Element], _SequenceRegister>()
     var strings = TypedSetVector<String, _StringRegister>()
     var consumeFunctions: [ConsumeFunction] = []
 
@@ -141,6 +142,14 @@ extension Program.Builder {
       .match, .init(element: elements.store(e))))
   }
 
+  public mutating func buildMatchSequence<S: Sequence>(
+    _ s: S
+  ) where S.Element == Input.Element {
+    instructions.append(.init(
+      .matchSequence,
+      .init(sequence: sequences.store(.init(s)))))
+  }
+
   public mutating func buildConsume(
     by p: @escaping Program.ConsumeFunction
   ) {
@@ -212,6 +221,7 @@ extension Program.Builder {
 
     var regInfo = Program.RegisterInfo()
     regInfo.elements = elements.count
+    regInfo.sequences = sequences.count
     regInfo.strings = strings.count
     regInfo.bools = nextBoolRegister.rawValue
     regInfo.ints = nextIntRegister.rawValue
@@ -220,6 +230,7 @@ extension Program.Builder {
     return Program(
       instructions: InstructionList(instructions),
       staticElements: elements.stored,
+      staticSequences: sequences.stored,
       staticStrings: strings.stored,
       staticConsumeFunctions: consumeFunctions,
       registerInfo: regInfo)

Sources/_MatchingEngine/Engine/InstPayload.swift

@@ -31,6 +31,7 @@ extension Instruction.Payload {
     // and variables
 
     case string(StringRegister)
+    case sequence(SequenceRegister)
     case optionalString(StringRegister?)
     case int(IntRegister)
     case distance(Distance)
@@ -127,6 +128,13 @@ extension Instruction.Payload {
     interpret()
   }
 
+  init(sequence: SequenceRegister) {
+    self.init(sequence)
+  }
+  var sequence: SequenceRegister {
+    interpret()
+  }
+
   init(optionalString: StringRegister?) {
     self.init(optionalString)
   }

Sources/_MatchingEngine/Engine/Instruction.swift

@@ -116,6 +116,11 @@ extension Instruction {
     /// Operand: Element register to compare against.
     case match
 
+    /// Match against a sequence of elements
+    ///
+    /// Operand: Sequence register to compare against.
+    case matchSequence
+
     /// Match against a provided element.
     ///
     /// Operand: Packed condition register to write to and element register to

Sources/_MatchingEngine/Engine/Processor.swift

@@ -127,6 +127,11 @@ extension Processor {
   func load() -> Element? {
     currentPosition < end ? input[currentPosition] : nil
   }
+  func load(count: Int) -> Input.SubSequence? {
+    let slice = input[currentPosition...].prefix(count)
+    guard slice.count == count else { return nil }
+    return slice
+  }
 
   mutating func signalFailure() {
     guard let (pc, pos, stackEnd) = savePoints.popLast()?.destructure
@@ -294,6 +299,22 @@ extension Processor {
         controller.step()
       }
 
+    case .matchSequence:
+      let reg = payload.sequence
+      let seq = registers[reg]
+      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()
+
     case .consumeBy:
       let reg = payload.consumer
       guard currentPosition < bounds.upperBound,

Sources/_MatchingEngine/Engine/Program.swift

@@ -3,6 +3,7 @@ public struct Program<Input: Collection> where Input.Element: Equatable {
   var instructions: InstructionList<Instruction>
 
   var staticElements: [Input.Element]
+  var staticSequences: [[Input.Element]]
   var staticStrings: [String]
   var staticConsumeFunctions: [ConsumeFunction]
 

Sources/_MatchingEngine/Engine/Registers.swift

@@ -4,6 +4,11 @@ extension Processor {
     // currently, these are static readonly
     var elements: [Element]
 
+    // currently, these are static readonly
+    //
+    // TODO: We want to be `String` instead of `[Character]`...
+    var sequences: [[Element]] = []
+
     // currently, hold output of assertions
     var bools: [Bool] // TODO: bitset
 
@@ -40,6 +45,9 @@ extension Processor {
     subscript(_ i: StringRegister) -> String {
       strings[i.rawValue]
     }
+    subscript(_ i: SequenceRegister) -> [Element] {
+      sequences[i.rawValue]
+    }
     subscript(_ i: IntRegister) -> Int {
       get { ints[i.rawValue] }
       set { ints[i.rawValue] = newValue }
@@ -67,6 +75,9 @@ extension Processor.Registers {
     self.elements = program.staticElements
     assert(elements.count == info.elements)
 
+    self.sequences = program.staticSequences
+    assert(sequences.count == info.sequences)
+
     self.consumeFunctions = program.staticConsumeFunctions
     assert(consumeFunctions.count == info.consumeFunctions)
 
@@ -94,6 +105,7 @@ extension Processor.Registers {
 extension Program {
   struct RegisterInfo {
     var elements = 0
+    var sequences = 0
     var bools = 0
     var strings = 0
     var consumeFunctions = 0

Sources/_MatchingEngine/Utility/TypedInt.swift

@@ -127,6 +127,9 @@ public enum _SavePointAddress {}
 public typealias ElementRegister = TypedInt<_ElementRegister>
 public enum _ElementRegister {}
 
+public typealias SequenceRegister = TypedInt<_SequenceRegister>
+public enum _SequenceRegister {}
+
 /// The register number for a stored boolean value
 ///
 /// E.g. used for conditional branches

Sources/_StringProcessing/Compiler.swift

@@ -92,7 +92,11 @@ class Compiler {
     case _ where try node.generateConsumer(matchLevel) != nil:
       try builder.buildConsume(by: node.generateConsumer(matchLevel)!)
 
-    case .quote, .customCharacterClass, .atom:
+    case .quote(let q):
+      // We stick quoted content into read-only constant strings
+      builder.buildMatchSequence(q.literal)
+
+    case .customCharacterClass, .atom:
       throw unsupported(node._dumpBase)
     }
   }

Tests/RegexTests/MatchTests.swift

@@ -121,13 +121,13 @@ extension RegexTests {
 
     matchTest(
       #"a\Q .\Eb"#,
-      input: "123a .bxyz", match: "a .b", xfail: true)
+      input: "123a .bxyz", match: "a .b")
     matchTest(
       #"a\Q \Q \\.\Eb"#,
-      input: #"123a \Q \\.bxyz"#, match: #"a \Q \\.b"#, xfail: true)
+      input: #"123a \Q \\.bxyz"#, match: #"a \Q \\.b"#)
     matchTest(
       #"\d\Q...\E"#,
-      input: "Countdown: 3... 2... 1...", match: "3...", xfail: true)
+      input: "Countdown: 3... 2... 1...", match: "3...")
 
     // MARK: Comments