wip: fast path for Ascii character class matching

Author: milseman

Sources/_StringProcessing/Engine/MEQuantify.swift

@@ -4,7 +4,7 @@ extension Processor {
 
     switch payload.type {
     case .bitset:
-      return input.matchBitset(
+      return input.matchASCIIBitset(
         registers[payload.bitset],
         at: currentPosition,
         limitedBy: end,

Sources/_StringProcessing/Engine/Processor.swift

@@ -291,7 +291,7 @@ extension Processor {
     _ bitset: DSLTree.CustomCharacterClass.AsciiBitset,
     isScalarSemantics: Bool
   ) -> Bool {
-    guard let next = input.matchBitset(
+    guard let next = input.matchASCIIBitset(
       bitset,
       at: currentPosition,
       limitedBy: end,
@@ -727,30 +727,59 @@ extension String {
     return idx
   }
 
-  func matchBitset(
+  // TODO: effects? release none? conuming self?
+  private func _getNextIndex(
+    at pos: Index, isScalarSemantics: Bool, returnNil: Bool
+  ) -> Index? {
+    assert(pos < endIndex)
+    if returnNil { return nil }
+    if isScalarSemantics {
+      return self.unicodeScalars.index(after: pos)
+    }
+    return self.index(after: pos)
+  }
+
+  func matchASCIIBitset(
     _ bitset: DSLTree.CustomCharacterClass.AsciiBitset,
     at pos: Index,
     limitedBy end: Index,
     isScalarSemantics: Bool
   ) -> Index? {
-    // TODO: extremely quick-check-able
-    // TODO: can be sped up with string internals
     assert(end <= endIndex)
 
     guard pos < end else { return nil }
 
-    let idx: String.Index
-    if isScalarSemantics {
-      guard bitset.matches(unicodeScalars[pos]) else { return nil }
-      idx = unicodeScalars.index(after: pos)
-    } else {
-      guard bitset.matches(self[pos]) else { return nil }
-      idx = index(after: pos)
+    // TODO: Inversion should be tracked and handled in only one place..
+    let isInverted = bitset.isInverted
+
+    // TODO: Want something more specialized, so overhaul/refactor _quickASCIICharacter
+    guard let (byte, next, isCRLF) = _quickASCIICharacter(at: pos) else {
+      // FIXME: what if following index is beyond end?
+      if isScalarSemantics {
+        return bitset.matches(self.unicodeScalars[pos]) ? self.unicodeScalars.index(after: pos) : nil
+      }
+
+      return bitset.matches(self[pos]) ? self.index(after: pos) : nil
     }
 
-    guard idx <= end else { return nil }
-    return idx
-  }
+    // TODO: refactor, this checks the inversion property for us
+    guard bitset.matches(byte) else {
+      return nil
+    }
 
+    // CR-LF should only match `[\r]` in scalar semantic mode or if inverted
+    if isCRLF {
+      // TODO: what if next is past `end` because CRLF?
+      // FIXME: quickASCIICharacter probably needs a limtedBy argument
+      if isScalarSemantics {
+        return self.unicodeScalars.index(before: next)
+      }
+      if isInverted {
+        return next
+      }
+      return nil
+    }
 
+    return next
+  }
 }

Sources/_StringProcessing/Utility/AsciiBitset.swift

@@ -49,18 +49,24 @@ extension DSLTree.CustomCharacterClass {
       }
     }
 
-    private func matches(_ val: UInt8) -> Bool {
+    // Whether the val matches (without checking for inversion) the bitset
+    internal func _matchesWithoutInversion(_ val: UInt8) -> Bool {
       if val < 64 {
         return (a >> val) & 1 == 1
       } else {
         return (b >> (val - 64)) & 1 == 1
       }
     }
 
+    internal func matches(_ byte: UInt8) -> Bool {
+      guard byte < 128 else { return isInverted }
+      return _matchesWithoutInversion(byte) == !isInverted
+    }
+
     internal func matches(_ char: Character) -> Bool {
       let matched: Bool
       if let val = char._singleScalarAsciiValue {
-        matched = matches(val)
+        matched = _matchesWithoutInversion(val)
       } else {
         matched = false
       }
@@ -75,7 +81,7 @@ extension DSLTree.CustomCharacterClass {
       let matched: Bool
       if scalar.isASCII {
         let val = UInt8(ascii: scalar)
-        matched = matches(val)
+        matched = _matchesWithoutInversion(val)
       } else {
         matched = false
       }