wip

Author: milseman

Sources/_StringProcessing/Engine/MEBuiltins.swift

@@ -9,39 +9,78 @@ extension Character {
 }
 
 extension Processor {
-  mutating func matchBuiltin(
+  mutating func matchBuiltinCC(
     _ cc: _CharacterClassModel.Representation,
-    _ isInverted: Bool,
-    _ isStrictASCII: Bool,
-    _ isScalarSemantics: Bool
+    isInverted: Bool,
+    isStrictASCII: Bool,
+    isScalarSemantics: Bool
   ) -> Bool {
-    guard let next = _doMatchBuiltin(
+    guard let next = _doMatchBuiltinCC(
       cc,
-      isInverted,
-      isStrictASCII,
-      isScalarSemantics
+      isInverted: isInverted,
+      isStrictASCII: isStrictASCII,
+      isScalarSemantics: isScalarSemantics
     ) else {
       signalFailure()
       return false
     }
     currentPosition = next
     return true
   }
-  
-  func _doMatchBuiltin(
+
+  func _doMatchBuiltinCC(
     _ cc: _CharacterClassModel.Representation,
-    _ isInverted: Bool,
-    _ isStrictASCII: Bool,
-    _ isScalarSemantics: Bool
+    isInverted: Bool,
+    isStrictASCII: Bool,
+    isScalarSemantics: Bool
   ) -> Input.Index? {
+    switch _quickMatchBuiltinCC(
+      cc, 
+      isInverted: isInverted, 
+      isStrictASCII: isStrictASCII,
+      isScalarSemantics: isScalarSemantics
+    ) {
+      case .no:
+        return nil
+      case .yes(let next):
+        return next
+      case .maybe:
+        return _slowMatchBuiltinCC(
+          cc, 
+          isInverted: isInverted, 
+          isStrictASCII: isStrictASCII,
+          isScalarSemantics: isScalarSemantics)
+    }
+  }
 
-    // ASCII fast-path
-    if let (next, result) = input._quickMatch(
+  @inline(__always)
+  func _quickMatchBuiltinCC(
+    _ cc: _CharacterClassModel.Representation,
+    isInverted: Bool,
+    isStrictASCII: Bool,
+    isScalarSemantics: Bool
+  ) -> QuickResult<Input.Index> {
+    guard let (next, result) = input._quickMatch(
       cc, at: currentPosition, isScalarSemantics: isScalarSemantics
-    ) {
-      return result == isInverted ? nil : next
+    ) else {
+      return .maybe
     }
+    let idx = result == isInverted ? nil : next
+    assert(idx == _slowMatchBuiltinCC(
+      cc, 
+      isInverted: isInverted,
+      isStrictASCII: isStrictASCII,
+      isScalarSemantics: isScalarSemantics))
+    return .definite(idx)
+  }
 
+  @inline(never)
+  func _slowMatchBuiltinCC(
+    _ cc: _CharacterClassModel.Representation,
+    isInverted: Bool,
+    isStrictASCII: Bool,
+    isScalarSemantics: Bool
+  ) -> Input.Index? {
     guard let char = load(), let scalar = loadScalar() else {
       return nil
     }

Sources/_StringProcessing/Engine/MEQuantify.swift

@@ -9,11 +9,11 @@ extension Processor {
         UnicodeScalar.init(_value: UInt32(payload.asciiChar)), true)
     case .builtin:
       // We only emit .quantify if it consumes a single character
-      next = _doMatchBuiltin(
+      next = _doMatchBuiltinCC(
         payload.builtin,
-        payload.builtinIsInverted,
-        payload.builtinIsStrict,
-        false)
+        isInverted: payload.builtinIsInverted,
+        isStrictASCII: payload.builtinIsStrict,
+        isScalarSemantics: false)
     case .any:
       let matched = currentPosition != input.endIndex
         && (!input[currentPosition].isNewline || payload.anyMatchesNewline)

Sources/_StringProcessing/Engine/Processor.swift

@@ -583,11 +583,11 @@ extension Processor {
 
     case .matchBuiltin:
       let payload = payload.characterClassPayload
-      if matchBuiltin(
+      if matchBuiltinCC(
         payload.cc,
-        payload.isInverted,
-        payload.isStrictASCII,
-        payload.isScalarSemantics
+        isInverted: payload.isInverted,
+        isStrictASCII: payload.isStrictASCII,
+        isScalarSemantics: payload.isScalarSemantics
       ) {
         controller.step()
       }

Sources/_StringProcessing/StringExtras.swift

@@ -128,3 +128,19 @@ extension String {
 
 }
 
+/// An enum for quick-check functions, which could return a yes, no, or maybe
+/// result.
+enum QuickResult<R> {
+  case yes(_ r: R)
+  case no
+  case maybe
+
+  static func definite(_ r: R?) -> QuickResult {
+    if let r = r {
+      return .yes(r)
+    }
+    return .no
+  }
+}
+
+