Add support for canonical combining class

Sources/_RegexParser/Regex/AST/Atom.swift

@@ -436,6 +436,9 @@ extension AST.Atom.CharacterProperty {
     /// Case mapping.
     case mapping(MapKind, String)
 
+    /// Canonical Combining Class.
+    case ccc(Unicode.CanonicalCombiningClass)
+
     /// Character age, as per UnicodeScalar.Properties.age.
     case age(major: Int, minor: Int)
 

Sources/_RegexParser/Regex/Parse/CharacterPropertyClassification.swift

@@ -488,6 +488,11 @@ extension Source {
         return .mapping(.uppercase, value)
       case "stc", "simpletitlecasemapping":
         return .mapping(.titlecase, value)
+      case "ccc", "canonicalcombiningclass":
+        guard let cccValue = UInt8(value), cccValue <= 254 else {
+          throw ParseError.invalidCCC(value)
+        }
+        return .ccc(.init(rawValue: cccValue))
       default:
         break
       }

Sources/_RegexParser/Regex/Parse/Diagnostics.swift

@@ -64,7 +64,7 @@ enum ParseError: Error, Hashable {
   case invalidAge(String)
   case invalidNumericValue(String)
   case unrecognizedNumericType(String)
-  case expectedMapping(String)
+  case invalidCCC(String)
 
   case expectedGroupSpecifier
   case unbalancedEndOfGroup
@@ -197,8 +197,8 @@ extension ParseError: CustomStringConvertible {
       return "invalid age format for '\(value)' - use '3.0' or 'V3_0' formats"
     case .invalidNumericValue(let value):
       return "invalid numeric value '\(value)'"
-    case .expectedMapping(let mapping):
-      return "missing value for '\(mapping)'"
+    case .invalidCCC(let value):
+      return "invalid canonical combining class '\(value)'"
 
     // MARK: Semantic Errors
 

Sources/_RegexParser/Regex/Parse/Sema.swift

@@ -169,7 +169,7 @@ extension RegexValidator {
     case .binary(let b, _):
       try validateBinaryProperty(b, at: loc)
     case .any, .assigned, .ascii, .generalCategory, .posix, .named, .script,
-        .scriptExtension, .age, .numericType, .numericValue, .mapping:
+        .scriptExtension, .age, .numericType, .numericValue, .mapping, .ccc:
       break
     case .pcreSpecial:
       throw error(.unsupported("PCRE property"), at: loc)

Sources/_StringProcessing/ConsumerInterface.swift

@@ -500,6 +500,9 @@ extension AST.Atom.CharacterProperty {
       case .numericType(let type):
         return consume { $0.properties.numericType == type }
 
+      case .ccc(let ccc):
+        return consume { $0.properties.canonicalCombiningClass == ccc }
+
       case .mapping(.lowercase, let value):
         return consume { $0.properties.lowercaseMapping == value }
 

Tests/RegexTests/ParseTests.swift

@@ -2475,6 +2475,8 @@ extension RegexTests {
     diagnosticTest(#"\p{Numeric_Type=Nuemric}"#, .unrecognizedNumericType("Nuemric"))
     diagnosticTest(#"\p{Simple_Lowercase_Mapping}"#, .unknownProperty(key: nil, value: "Simple_Lowercase_Mapping"))
     diagnosticTest(#"\p{Simple_Lowercase_Mapping=}"#, .emptyProperty)
+    diagnosticTest(#"\p{ccc=255}"#, .invalidCCC("255"))
+    diagnosticTest(#"\p{ccc=Nada}"#, .invalidCCC("Nada"))
     diagnosticTest(#"(?#"#, .expected(")"))
     diagnosticTest(#"(?x"#, .expected(")"))
 

Tests/RegexTests/UTS18Tests.swift

@@ -715,8 +715,8 @@ extension UTS18Tests {
 
     // MARK: Normalization
     // Canonical_Combining_Class
-//    XCTAssertTrue("abc".contains(regex(#"^\p{Canonical_Combining_Class}+$"#)))
-//    XCTAssertFalse("123".contains(regex(#"\p{Canonical_Combining_Class}"#)))
+    XCTAssertTrue("\u{0321}\u{0322}\u{1DD0}".contains(regex(#"^\p{Canonical_Combining_Class=202}+$"#)))
+    XCTAssertFalse("123".contains(regex(#"\p{Canonical_Combining_Class=202}"#)))
 
     // Decomposition_Type
 //    XCTAssertTrue("abc".contains(regex(#"^\p{Decomposition_Type}+$"#)))