Parse PCRE callouts, backtracking directives, and .NET balanced captures

Sources/_MatchingEngine/Regex/AST/AST.swift

@@ -100,6 +100,20 @@ extension AST {
 
     return self.children?.any(\.hasCapture) ?? false
   }
+
+  /// Whether this AST node may be used as the operand of a quantifier such as
+  /// `?`, `+` or `*`.
+  public var isQuantifiable: Bool {
+    switch self {
+    case .atom(let a):
+      return a.isQuantifiable
+    case .group, .conditional, .customCharacterClass:
+      return true
+    case .alternation, .concatenation, .quantification, .quote, .trivia,
+        .empty, .groupTransform:
+      return false
+    }
+  }
 }
 
 // MARK: - AST types

Sources/_MatchingEngine/Regex/AST/Atom.swift

@@ -66,6 +66,12 @@ extension AST {
       // References
       case backreference(Reference)
       case subpattern(Reference)
+
+      // (?C)
+      case callout(Callout)
+
+      // (*ACCEPT), (*FAIL), ...
+      case backtrackingDirective(BacktrackingDirective)
     }
   }
 }
@@ -443,6 +449,59 @@ extension AST.Atom {
   }
 }
 
+extension AST.Atom {
+  public struct Callout: Hashable {
+    public enum Argument: Hashable {
+      case number(Int)
+      case string(String)
+    }
+    public var arg: AST.Located<Argument>
+    public init(_ arg: AST.Located<Argument>) {
+      self.arg = arg
+    }
+  }
+}
+
+extension AST.Atom {
+  public struct BacktrackingDirective: Hashable {
+    public enum Kind: Hashable {
+      /// (*ACCEPT)
+      case accept
+
+      /// (*FAIL)
+      case fail
+
+      /// (*MARK:NAME)
+      case mark
+
+      /// (*COMMIT)
+      case commit
+
+      /// (*PRUNE)
+      case prune
+
+      /// (*SKIP)
+      case skip
+
+      /// (*THEN)
+      case then
+    }
+    public var kind: AST.Located<Kind>
+    public var name: AST.Located<String>?
+
+    public init(_ kind: AST.Located<Kind>, name: AST.Located<String>?) {
+      self.kind = kind
+      self.name = name
+    }
+
+    public var isQuantifiable: Bool {
+      // As per http://pcre.org/current/doc/html/pcre2pattern.html#SEC29, only
+      // (*ACCEPT) is quantifiable.
+      kind.value == .accept
+    }
+  }
+}
+
 extension AST.Atom {
   /// Retrieve the character value of the atom if it represents a literal
   /// character or unicode scalar, nil otherwise.
@@ -458,7 +517,8 @@ extension AST.Atom {
       fallthrough
 
     case .property, .escaped, .any, .startOfLine, .endOfLine,
-        .backreference, .subpattern, .namedCharacter:
+        .backreference, .subpattern, .namedCharacter, .callout,
+        .backtrackingDirective:
       return nil
     }
   }
@@ -483,10 +543,21 @@ extension AST.Atom {
       return "\\M-\\C-\(x)"
 
     case .property, .escaped, .any, .startOfLine, .endOfLine,
-        .backreference, .subpattern, .namedCharacter:
+        .backreference, .subpattern, .namedCharacter, .callout,
+        .backtrackingDirective:
       return nil
     }
   }
+
+  public var isQuantifiable: Bool {
+    switch kind {
+    case .backtrackingDirective(let b):
+      return b.isQuantifiable
+    // TODO: Are callouts quantifiable?
+    default:
+      return true
+    }
+  }
 }
 
 extension AST {

Sources/_MatchingEngine/Regex/AST/Group.swift

@@ -31,6 +31,9 @@ extension AST {
       // (?<name>...) (?'name'...) (?P<name>...)
       case namedCapture(Located<String>)
 
+      // (?<name-priorName>) (?'name-priorName')
+      case balancedCapture(BalancedCapture)
+
       // (?:...)
       case nonCapture
 
@@ -79,7 +82,7 @@ extension AST {
 extension AST.Group.Kind {
   public var isCapturing: Bool {
     switch self {
-    case .capture, .namedCapture: return true
+    case .capture, .namedCapture, .balancedCapture: return true
     default: return false
     }
   }
@@ -103,6 +106,7 @@ extension AST.Group.Kind {
   public var name: String? {
     switch self {
     case .namedCapture(let name): return name.value
+    case .balancedCapture(let b): return b.name?.value
     default: return nil
     }
   }
@@ -121,5 +125,26 @@ extension AST.Group {
     default: return nil
     }
   }
+}
+
+extension AST.Group {
+  public struct BalancedCapture: Hashable {
+    /// The name of the group, or nil if the group has no name.
+    public var name: AST.Located<String>?
+
+    /// The location of the `-` in the group.
+    public var dash: SourceLocation
 
+    /// The name of the prior group that the balancing group references.
+    public var priorName: AST.Located<String>
+
+    public init(
+      name: AST.Located<String>?, dash: SourceLocation,
+      priorName: AST.Located<String>
+    ) {
+      self.name = name
+      self.dash = dash
+      self.priorName = priorName
+    }
+  }
 }

Sources/_MatchingEngine/Regex/Parse/CaptureStructure.swift

@@ -44,7 +44,10 @@ extension AST {
         return .atom() + innerCaptures
       case .namedCapture(let name):
         return .atom(name: name.value) + innerCaptures
+      case .balancedCapture(let b):
+        return .atom(name: b.name?.value) + innerCaptures
       default:
+        precondition(!group.kind.value.isCapturing)
         return innerCaptures
       }
     case .conditional(let c):

Sources/_MatchingEngine/Regex/Parse/Diagnostics.swift

@@ -38,7 +38,12 @@ enum ParseError: Error, Hashable {
 
   case cannotReferToWholePattern
 
+  case notQuantifiable
+
+  case backtrackingDirectiveMustHaveName(String)
+
   case unknownGroupKind(String)
+  case unknownCalloutKind(String)
 
   case invalidMatchingOption(Character)
   case cannotRemoveMatchingOptionsAfterCaret
@@ -50,6 +55,9 @@ enum ParseError: Error, Hashable {
   case emptyProperty
 
   case expectedGroupSpecifier
+  case expectedGroupName
+  case groupNameMustBeAlphaNumeric
+  case groupNameCannotStartWithNumber
   case cannotRemoveTextSegmentOptions
 }
 
@@ -80,12 +88,18 @@ extension ParseError: CustomStringConvertible {
       return "expected escape sequence"
     case .cannotReferToWholePattern:
       return "cannot refer to whole pattern here"
+    case .notQuantifiable:
+      return "expression is not quantifiable"
+    case .backtrackingDirectiveMustHaveName(let b):
+      return "backtracking directive '\(b)' must include name"
     case let .tooManyBranchesInConditional(i):
       return "expected 2 branches in conditional, have \(i)"
     case let .unsupportedCondition(str):
       return "\(str) cannot be used as condition"
     case let .unknownGroupKind(str):
       return "unknown group kind '(\(str)'"
+    case let .unknownCalloutKind(str):
+      return "unknown callout kind '\(str)'"
     case let .invalidMatchingOption(c):
       return "invalid matching option '\(c)'"
     case .cannotRemoveMatchingOptionsAfterCaret:
@@ -102,6 +116,12 @@ extension ParseError: CustomStringConvertible {
       return "empty property"
     case .expectedGroupSpecifier:
       return "expected group specifier"
+    case .expectedGroupName:
+      return "expected group name"
+    case .groupNameMustBeAlphaNumeric:
+      return "group name must only contain alphanumeric characters"
+    case .groupNameCannotStartWithNumber:
+      return "group name must not start with number"
     case .cannotRemoveTextSegmentOptions:
       return "text segment mode cannot be unset, only changed"
     }