Add case-insensitive match instructions

Add case-insensitive match instructions

Author: rctcwyvrn

Sources/_StringProcessing/ByteCodeGen.swift

@@ -45,10 +45,10 @@ fileprivate extension Compiler.ByteCodeGen {
       emitAny()
 
     case let .char(c):
-      try emitCharacter(c)
+      emitCharacter(c)
 
     case let .scalar(s):
-      try emitScalar(s)
+      emitScalar(s)
 
     case let .assertion(kind):
       try emitAssertion(kind.ast)
@@ -74,81 +74,32 @@ fileprivate extension Compiler.ByteCodeGen {
     }
   }
 
-  mutating func emitScalarQuotedLiteral(_ s: String) {
-    precondition(options.semanticLevel == .unicodeScalar)
-    if optimizationsEnabled && !options.isCaseInsensitive {
-      // Match all scalars exactly, never boundary check because we're in
-      // unicode scalars mode
-      for char in s {
-        for scalar in char.unicodeScalars {
-          builder.buildMatchScalar(scalar, boundaryCheck: false)
-        }
-      }
-      return
-    }
-
-    builder.buildConsume {
-      [caseInsensitive = options.isCaseInsensitive] input, bounds in
-      // TODO: Case folding
-      var iterator = s.unicodeScalars.makeIterator()
-      var currentIndex = bounds.lowerBound
-      while let scalar = iterator.next() {
-        guard currentIndex < bounds.upperBound else { return nil }
-        if caseInsensitive {
-          if scalar.properties.lowercaseMapping != input.unicodeScalars[currentIndex].properties.lowercaseMapping {
-            return nil
-          }
-        } else {
-          if scalar != input.unicodeScalars[currentIndex] {
-            return nil
-          }
-        }
-        input.unicodeScalars.formIndex(after: &currentIndex)
-      }
-      return currentIndex
-    }
-  }
-
   mutating func emitQuotedLiteral(_ s: String) {
     guard options.semanticLevel == .graphemeCluster else {
-      emitScalarQuotedLiteral(s)
-      return
-    }
-
-    if options.isCaseInsensitive {
-      // future work: if all ascii, emit matchBitset instructions with
-      // case insensitive bitsets
-      // TODO: buildCaseInsensitiveMatchSequence(c) or alternative
-      builder.buildConsume { input, bounds in
-        var iterator = s.makeIterator()
-        var currentIndex = bounds.lowerBound
-        while let ch = iterator.next() {
-          guard currentIndex < bounds.upperBound,
-                ch.lowercased() == input[currentIndex].lowercased()
-          else { return nil }
-          input.formIndex(after: &currentIndex)
+      for char in s {
+        for scalar in char.unicodeScalars {
+          emitScalar(scalar)
         }
-        return currentIndex
       }
       return
     }
 
+    // Fast path for eliding boundary checks for an all ascii quoted literal
     if optimizationsEnabled && s.allSatisfy({char in char.isASCII}) {
       let lastIdx = s.unicodeScalars.indices.last!
       for idx in s.unicodeScalars.indices {
-        if idx == lastIdx {
-          // Only boundary check if we are the last scalar in the last character
-          // to make sure that there isn't a combining scalar after the quoted literal
-          builder.buildMatchScalar(s.unicodeScalars[idx], boundaryCheck: true)
+        let boundaryCheck = idx == lastIdx
+        let scalar = s.unicodeScalars[idx]
+        if options.isCaseInsensitive && scalar.properties.isCased {
+          builder.buildMatchScalarCaseInsensitive(scalar, boundaryCheck: boundaryCheck)
         } else {
-          builder.buildMatchScalar(s.unicodeScalars[idx], boundaryCheck: false)
+          builder.buildMatchScalar(scalar, boundaryCheck: boundaryCheck)
         }
       }
       return
     }
 
-    builder.buildMatchSequence(s)
-    return
+    for c in s { emitCharacter(c) }
   }
 
   mutating func emitBackreference(
@@ -286,35 +237,29 @@ fileprivate extension Compiler.ByteCodeGen {
     }
   }
 
-  mutating func emitScalar(_ s: UnicodeScalar) throws {
-    if options.isCaseInsensitive {
-      // TODO: e.g. buildCaseInsensitiveMatchScalar(s)
-      builder.buildConsume(by: consumeScalar {
-        $0.properties.lowercaseMapping == s.properties.lowercaseMapping
-      })
-      return
+  mutating func emitScalar(_ s: UnicodeScalar) {
+    if options.isCaseInsensitive && s.properties.isCased {
+      builder.buildMatchScalarCaseInsensitive(s, boundaryCheck: false)
+    } else {
+      builder.buildMatchScalar(s, boundaryCheck: false)
     }
-    
-    builder.buildMatchScalar(s, boundaryCheck: false)
   }
 
-  mutating func emitCharacter(_ c: Character) throws {
+  mutating func emitCharacter(_ c: Character) {
     // Unicode scalar mode matches the specific scalars that comprise a character
     if options.semanticLevel == .unicodeScalar {
       for scalar in c.unicodeScalars {
-        try emitScalar(scalar)
+        emitScalar(scalar)
       }
       return
     }
 
     if options.isCaseInsensitive && c.isCased {
-      // TODO: buildCaseInsensitiveMatch(c) or buildMatch(c, caseInsensitive: true)
-      builder.buildConsume { input, bounds in
-        let inputChar = input[bounds.lowerBound].lowercased()
-        let matchChar = c.lowercased()
-        return inputChar == matchChar
-          ? input.index(after: bounds.lowerBound)
-          : nil
+      if optimizationsEnabled && c.isASCII {
+        // c.isCased ensures that c is not CR-LF, so we know that c is a single scalar
+        builder.buildMatchScalarCaseInsensitive(c.unicodeScalars.last!, boundaryCheck: true)
+      } else {
+        builder.buildMatchCaseInsensitive(c)
       }
       return
     }

Sources/_StringProcessing/Engine/Instruction.swift

@@ -77,16 +77,42 @@ extension Instruction {
     /// Operand: Element register to compare against.
     case match
 
+    /// Matches the given character case insensitively
+    ///
+    ///     match(_: EltReg)
+    ///
+    /// Operand: Element register to compare against.
+    case matchCaseInsensitive
+
     /// Match against a sequence of elements
     ///
     ///     matchSequence(_: SeqReg)
     ///
     /// Operand: Sequence register to compare against.
     case matchSequence
 
+    /// Match against a scalar and perform a grapheme boundary check
+    ///
+    ///     matchScalar(_: Unicode.Scalar)
+    /// Operand: Scalar value to match against
     case matchScalar
+    /// Match against a scalar and do NOT perform a grapheme boundary check
+    ///
+    ///     matchScalarUnchecked(_: Unicode.Scalar)
+    /// Operand: Scalar value to match against
     case matchScalarUnchecked
 
+    /// Match against a scalar case insensitively and perform a grapheme boundary check
+    ///
+    ///     matchScalarCaseInsensitive(_: Unicode.Scalar)
+    /// Operand: Scalar value to match against
+    case matchScalarCaseInsensitive
+    /// Match against a scalar case insensitively and do NOT perform a grapheme boundary check
+    ///
+    ///     matchScalarCaseInsensitiveUnchecked(_: Unicode.Scalar)
+    /// Operand: Scalar value to match against
+    case matchScalarCaseInsensitiveUnchecked
+
     /// Match against a set of valid ascii values stored in a bitset
     /// Operand: Ascii bitset register containing the bitset
     case matchBitset

Sources/_StringProcessing/Engine/MEBuilder.swift

@@ -140,6 +140,11 @@ extension MEProgram.Builder {
       .match, .init(element: elements.store(e))))
   }
 
+  mutating func buildMatchCaseInsensitive(_ e: Character) {
+    instructions.append(.init(
+      .matchCaseInsensitive, .init(element: elements.store(e))))
+  }
+
   mutating func buildMatchSequence<S: Sequence>(
     _ s: S
   ) where S.Element == Character {
@@ -155,6 +160,15 @@ extension MEProgram.Builder {
       instructions.append(.init(.matchScalarUnchecked, .init(scalar: s)))
     }
   }
+  
+  mutating func buildMatchScalarCaseInsensitive(_ s: Unicode.Scalar, boundaryCheck: Bool) {
+    if boundaryCheck {
+      instructions.append(.init(.matchScalarCaseInsensitive, .init(scalar: s)))
+    } else {
+      instructions.append(.init(.matchScalarCaseInsensitiveUnchecked, .init(scalar: s)))
+    }
+  }
+
 
   mutating func buildMatchAsciiBitset(
     _ b: DSLTree.CustomCharacterClass.AsciiBitset

Sources/_StringProcessing/Engine/Processor.swift

@@ -216,6 +216,15 @@ extension Processor {
     return true
   }
 
+  mutating func matchCaseInsensitive(_ e: Element) -> Bool {
+    guard let cur = load(), cur.lowercased() == e.lowercased() else {
+      signalFailure()
+      return false
+    }
+    _uncheckedForcedConsumeOne()
+    return true
+  }
+
   // Match against the current input prefix. Returns whether
   // it succeeded vs signaling an error.
   mutating func matchSeq<C: Collection>(
@@ -233,7 +242,29 @@ extension Processor {
 
   mutating func matchScalar(_ s: Unicode.Scalar, boundaryCheck: Bool) -> Bool {
     guard s == loadScalar(),
-          let idx = input.unicodeScalars.index(currentPosition, offsetBy: 1, limitedBy: end),
+          let idx = input.unicodeScalars.index(
+            currentPosition,
+            offsetBy: 1,
+            limitedBy: end),
+          (!boundaryCheck || input.isOnGraphemeClusterBoundary(idx))
+    else {
+      signalFailure()
+      return false
+    }
+    currentPosition = idx
+    return true
+  }
+
+  mutating func matchScalarCaseInsensitive(
+    _ s: Unicode.Scalar,
+    boundaryCheck: Bool
+  ) -> Bool {
+    guard let curScalar = loadScalar(),
+          s.properties.lowercaseMapping == curScalar.properties.lowercaseMapping,
+          let idx = input.unicodeScalars.index(
+            currentPosition,
+            offsetBy: 1,
+            limitedBy: end),
           (!boundaryCheck || input.isOnGraphemeClusterBoundary(idx))
     else {
       signalFailure()
@@ -400,6 +431,11 @@ extension Processor {
       if match(registers[reg]) {
         controller.step()
       }
+    case .matchCaseInsensitive:
+      let reg = payload.element
+      if matchCaseInsensitive(registers[reg]) {
+        controller.step()
+      }
 
     case .matchSequence:
       let reg = payload.sequence
@@ -418,6 +454,16 @@ extension Processor {
       if matchScalar(scalar, boundaryCheck: false) {
         controller.step()
       }
+    case .matchScalarCaseInsensitive:
+      let scalar = payload.scalar
+      if matchScalarCaseInsensitive(scalar, boundaryCheck: true) {
+        controller.step()
+      }
+    case .matchScalarCaseInsensitiveUnchecked:
+      let scalar = payload.scalar
+      if matchScalarCaseInsensitive(scalar, boundaryCheck: false) {
+        controller.step()
+      }
 
     case .matchBitset:
       let reg = payload.bitset