Remove extra instructions and use payload bits instead

Author: rctcwyvrn

Sources/_StringProcessing/ByteCodeGen.swift

@@ -259,7 +259,7 @@ fileprivate extension Compiler.ByteCodeGen {
         // 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)
+        builder.buildMatch(c, isCaseInsensitive: true)
       }
       return
     }
@@ -272,7 +272,7 @@ fileprivate extension Compiler.ByteCodeGen {
       return
     }
 
-    builder.buildMatch(c)
+    builder.buildMatch(c, isCaseInsensitive: false)
   }
 
   mutating func emitAny() {

Sources/_StringProcessing/Engine/InstPayload.swift

@@ -155,6 +155,19 @@ extension Instruction.Payload {
     return Unicode.Scalar(_value: UInt32(self.rawValue))
   }
 
+  init(scalar: Unicode.Scalar, caseInsensitive: Bool, boundaryCheck: Bool) {
+    let raw = UInt64(scalar.value)
+      + (caseInsensitive ? 1 << 55: 0)
+      + (boundaryCheck ? 1 << 54 : 0)
+    self.init(raw)
+  }
+  var scalarPayload: (Unicode.Scalar, caseInsensitive: Bool, boundaryCheck: Bool) {
+    let caseInsensitive = (self.rawValue >> 55) & 1 == 1
+    let boundaryCheck = (self.rawValue >> 54) & 1 == 1
+    let scalar = Unicode.Scalar(_value: UInt32(self.rawValue & 0xFFFF_FFFF))
+    return (scalar, caseInsensitive: caseInsensitive, boundaryCheck: boundaryCheck)
+  }
+
   init(sequence: SequenceRegister) {
     self.init(sequence)
   }
@@ -197,18 +210,20 @@ extension Instruction.Payload {
     interpret()
   }
 
-  init(element: ElementRegister) {
-    self.init(element)
+  init(element: ElementRegister, isCaseInsensitive: Bool) {
+    self.init(isCaseInsensitive ? 1 : 0, element)
   }
-  var element: ElementRegister {
-    interpret()
+  var elementPayload: (isCaseInsensitive: Bool, ElementRegister) {
+    let pair: (UInt64, ElementRegister) = interpretPair()
+    return (isCaseInsensitive: pair.0 == 1, pair.1)
   }
 
-  init(bitset: AsciiBitsetRegister) {
-    self.init(bitset)
+  init(bitset: AsciiBitsetRegister, isScalar: Bool) {
+    self.init(isScalar ? 1 : 0, bitset)
   }
-  var bitset: AsciiBitsetRegister {
-    interpret()
+  var bitsetPayload: (isScalar: Bool, AsciiBitsetRegister) {
+    let pair: (UInt64, AsciiBitsetRegister) = interpretPair()
+    return (isScalar: pair.0 == 1, pair.1)
   }
 
   init(consumer: ConsumeFunctionRegister) {

Sources/_StringProcessing/Engine/Instruction.swift

@@ -72,52 +72,28 @@ extension Instruction {
 
     /// Composite assert-advance else restore.
     ///
-    ///     match(_: EltReg)
+    ///     match(_: EltReg, isCaseInsensitive: Bool)
     ///
-    /// Operand: Element register to compare against.
+    /// Operands:
+    ///  - Element register to compare against.
+    ///  - Boolean for if we should match in a case insensitive way
     case match
 
-    /// Matches the given character case insensitively
-    ///
-    ///     match(_: EltReg)
-    ///
-    /// Operand: Element register to compare against.
-    case matchCaseInsensitive
-
-    /// Match against a sequence of elements
+    /// Match against a scalar and possibly perform a boundary check or match in a case insensitive way
     ///
-    ///     matchSequence(_: SeqReg)
+    ///     matchScalar(_: Unicode.Scalar, isCaseInsensitive: Bool, boundaryCheck: Bool)
     ///
-    /// 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
+    /// Operands: Scalar value to match against and booleans
     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
+    /// Match a character or a scalar against a set of valid ascii values stored in a bitset
     ///
-    ///     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
+    ///     matchBitset(_: AsciiBitsetRegister, isScalar: Bool)
     ///
-    ///     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
+    /// Operand:
+    ///  - Ascii bitset register containing the bitset
+    ///  - Boolean for if we should match by scalar value
     case matchBitset
-    /// matchBitset but emitted in unicode scalar semantic mode, matches and advances a single scalar
-    case matchBitsetScalar
 
     /// TODO: builtin assertions and anchors
     case builtinAssertion
@@ -337,7 +313,7 @@ extension Instruction {
   var elementRegister: ElementRegister? {
     switch opcode {
     case .match:
-      return payload.element
+      return payload.elementPayload.1
     default: return nil
     }
   }

Sources/_StringProcessing/Engine/MEBuilder.swift

@@ -135,53 +135,32 @@ extension MEProgram.Builder {
     instructions.append(.init(.advance, .init(distance: n)))
   }
 
-  mutating func buildMatch(_ e: Character) {
+  mutating func buildMatch(_ e: Character, isCaseInsensitive: Bool) {
     instructions.append(.init(
-      .match, .init(element: elements.store(e))))
+      .match, .init(element: elements.store(e), isCaseInsensitive: isCaseInsensitive)))
   }
 
-  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 {
-    instructions.append(.init(
-      .matchSequence,
-      .init(sequence: sequences.store(.init(s)))))
-  }
-  
   mutating func buildMatchScalar(_ s: Unicode.Scalar, boundaryCheck: Bool) {
-    if boundaryCheck {
-      instructions.append(.init(.matchScalar, .init(scalar: s)))
-    } else {
-      instructions.append(.init(.matchScalarUnchecked, .init(scalar: s)))
-    }
+    instructions.append(.init(.matchScalar, .init(scalar: s, caseInsensitive: false, boundaryCheck: boundaryCheck)))
   }
 
   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)))
-    }
+    instructions.append(.init(.matchScalar, .init(scalar: s, caseInsensitive: true, boundaryCheck: boundaryCheck)))
   }
 
 
   mutating func buildMatchAsciiBitset(
     _ b: DSLTree.CustomCharacterClass.AsciiBitset
   ) {
     instructions.append(.init(
-      .matchBitset, .init(bitset: makeAsciiBitset(b))))
+      .matchBitset, .init(bitset: makeAsciiBitset(b), isScalar: false)))
   }
 
   mutating func buildScalarMatchAsciiBitset(
     _ b: DSLTree.CustomCharacterClass.AsciiBitset
   ) {
     instructions.append(.init(
-      .matchBitsetScalar, .init(bitset: makeAsciiBitset(b))))
+      .matchBitset, .init(bitset: makeAsciiBitset(b), isScalar: true)))
   }
 
   mutating func buildConsume(

Sources/_StringProcessing/Engine/Processor.swift

@@ -427,55 +427,46 @@ extension Processor {
       }
 
     case .match:
-      let reg = payload.element
-      if match(registers[reg]) {
-        controller.step()
-      }
-    case .matchCaseInsensitive:
-      let reg = payload.element
-      if matchCaseInsensitive(registers[reg]) {
-        controller.step()
-      }
-
-    case .matchSequence:
-      let reg = payload.sequence
-      let seq = registers[reg]
-      if matchSeq(seq) {
-        controller.step()
+      let (isCaseInsensitive, reg) = payload.elementPayload
+      if isCaseInsensitive {
+        if matchCaseInsensitive(registers[reg]) {
+          controller.step()
+        }
+      } else {
+        if match(registers[reg]) {
+          controller.step()
+        }
       }
+//    case .matchSequence:
+//      let reg = payload.sequence
+//      let seq = registers[reg]
+//      if matchSeq(seq) {
+//        controller.step()
+//      }
 
     case .matchScalar:
-      let scalar = payload.scalar
-      if matchScalar(scalar, boundaryCheck: true) {
-        controller.step()
-      }
-    case .matchScalarUnchecked:
-      let scalar = payload.scalar
-      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()
+      let (scalar, caseInsensitive, boundaryCheck) = payload.scalarPayload
+      if caseInsensitive {
+        if matchScalarCaseInsensitive(scalar, boundaryCheck: boundaryCheck) {
+          controller.step()
+        }
+      } else {
+        if matchScalar(scalar, boundaryCheck: boundaryCheck) {
+          controller.step()
+        }
       }
 
     case .matchBitset:
-      let reg = payload.bitset
+      let (isScalar, reg) = payload.bitsetPayload
       let bitset = registers[reg]
-      if matchBitset(bitset) {
-        controller.step()
-      }
-    case .matchBitsetScalar:
-      let reg = payload.bitset
-      let bitset = registers[reg]
-      if matchBitsetScalar(bitset) {
-        controller.step()
+      if isScalar {
+        if matchBitsetScalar(bitset) {
+          controller.step()
+        }
+      } else {
+        if matchBitset(bitset) {
+          controller.step()
+        }
       }
 
     case .consumeBy: