[regexp] implement \p{Other_ID_Start} and \p{Other_ID_Continue}.

src/regexp/regexp-parser.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/regexp/regexp-parser.h"
 
 #include "src/char-predicates-inl.h"
 #include "src/factory.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
@@ skipping 1125 matching lines @@
   for (int i = 0;; i++) {
     const char* long_name = u_getPropertyValueName(
         property, property_value,
         static_cast<UPropertyNameChoice>(U_LONG_PROPERTY_NAME + i));
     if (long_name == NULL) break;
     if (strcmp(property_value_name, long_name) == 0) return true;
   }
   return false;
 }
 
-bool LookupPropertyValueName(UProperty property,
-                             const char* property_value_name, bool negate,
-                             ZoneList<CharacterRange>* result, Zone* zone) {
+bool LookupPropertyName(UProperty property, const char* property_value_name,
+                        bool negate, ZoneList<CharacterRange>* result,
+                        Zone* zone) {
   UProperty property_for_lookup = property;
   if (property_for_lookup == UCHAR_SCRIPT_EXTENSIONS) {
     // For the property Script_Extensions, we have to do the property value
     // name lookup as if the property is Script.
     property_for_lookup = UCHAR_SCRIPT;
   }
   int32_t property_value =
       u_getPropertyValueEnum(property_for_lookup, property_value_name);
   if (property_value == UCHAR_INVALID_CODE) return false;
 
@@ skipping 19 matching lines @@
     }
   }
   return success;
 }
 
 template <size_t N>
 inline bool NameEquals(const char* name, const char (&literal)[N]) {
   return strncmp(name, literal, N + 1) == 0;
 }
 
-bool LookupSpecialPropertyValueName(const char* name,
-                                    ZoneList<CharacterRange>* result,
-                                    bool negate, Zone* zone) {
+bool LookupSpecialPropertyName(const char* name,
+                               ZoneList<CharacterRange>* result, bool negate,
+                               Zone* zone) {
   if (NameEquals(name, "Any")) {
     if (!negate) result->Add(CharacterRange::Everything(), zone);
   } else if (NameEquals(name, "ASCII")) {
     result->Add(negate ? CharacterRange::Range(0x80, String::kMaxCodePoint)
                        : CharacterRange::Range(0x0, 0x7f),
                 zone);
   } else if (NameEquals(name, "Assigned")) {
-    return LookupPropertyValueName(UCHAR_GENERAL_CATEGORY, "Unassigned",
-                                   !negate, result, zone);
+    return LookupPropertyName(UCHAR_GENERAL_CATEGORY, "Unassigned", !negate,
+                              result, zone);
+  } else if (NameEquals(name, "Other_ID_Start") || NameEquals(name, "OIDS")) {
+    // From Unicode 9.0.0 PropList.txt
+    // 1885..1886    ; Other_ID_Start
+    // 2118          ; Other_ID_Start
+    // 212E          ; Other_ID_Start
+    // 309B..309C    ; Other_ID_Start
+    if (negate) {
+      result->Add(CharacterRange::Range(0x0000, 0x1884), zone);
+      result->Add(CharacterRange::Range(0x1887, 0x2117), zone);
+      result->Add(CharacterRange::Range(0x2119, 0x212D), zone);
+      result->Add(CharacterRange::Range(0x212F, 0x309A), zone);
+      result->Add(CharacterRange::Range(0x309D, String::kMaxCodePoint), zone);
+    } else {
+      result->Add(CharacterRange::Range(0x1885, 0x1886), zone);
+      result->Add(CharacterRange::Singleton(0x2118), zone);
+      result->Add(CharacterRange::Singleton(0x212E), zone);
+      result->Add(CharacterRange::Range(0x309B, 0x309C), zone);
+    }
+  } else if (NameEquals(name, "Other_ID_Continue") ||
+             NameEquals(name, "OIDC")) {
+    // From Unicode 9.0.0 PropList.txt
+    // 00B7          ; Other_ID_Continue
+    // 0387          ; Other_ID_Continue
+    // 1369..1371    ; Other_ID_Continue
+    // 19DA          ; Other_ID_Continue
+    if (negate) {
+      result->Add(CharacterRange::Range(0x0000, 0x00B6), zone);
+      result->Add(CharacterRange::Range(0x00B8, 0x0386), zone);
+      result->Add(CharacterRange::Range(0x0388, 0x1368), zone);
+      result->Add(CharacterRange::Range(0x1372, 0x19D9), zone);
+      result->Add(CharacterRange::Range(0x19DB, String::kMaxCodePoint), zone);
+    } else {
+      result->Add(CharacterRange::Singleton(0x00B7), zone);
+      result->Add(CharacterRange::Singleton(0x0387), zone);
+      result->Add(CharacterRange::Range(0x1369, 0x1371), zone);
+      result->Add(CharacterRange::Singleton(0x19DA), zone);
+    }
   } else {
     return false;
   }
   return true;
 }
 
 }  // anonymous namespace
 
 bool RegExpParser::ParsePropertyClass(ZoneList<CharacterRange>* result,
                                       bool negate) {
@@ skipping 22 matching lines @@
     }
   } else {
     return false;
   }
   Advance();
   first_part.Add(0);  // null-terminate string.
 
   if (second_part.is_empty()) {
     // First attempt to interpret as general category property value name.
     const char* name = first_part.ToConstVector().start();
-    if (LookupPropertyValueName(UCHAR_GENERAL_CATEGORY_MASK, name, negate,
-                                result, zone())) {
+    if (LookupPropertyName(UCHAR_GENERAL_CATEGORY_MASK, name, negate, result,
+                           zone())) {
       return true;
     }
-    // Interpret "Any", "ASCII", and "Assigned".
-    if (LookupSpecialPropertyValueName(name, result, negate, zone())) {
-      return true;
-    }
+
     // Then attempt to interpret as binary property name with value name 'Y'.
     UProperty property = u_getPropertyEnum(name);
+    if (property == UCHAR_INVALID_CODE) {
+      // Interpret "Any", "ASCII", "Assigned", "Other_ID_Start", and
+      // "Other_ID_Continue".
+      return LookupSpecialPropertyName(name, result, negate, zone());
+    }
     if (property < UCHAR_BINARY_START) return false;
     if (property >= UCHAR_BINARY_LIMIT) return false;
     if (!IsExactPropertyAlias(name, property)) return false;
-    return LookupPropertyValueName(property, negate ? "N" : "Y", false, result,
-                                   zone());
+    return LookupPropertyName(property, negate ? "N" : "Y", false, result,
+                              zone());
   } else {
     // Both property name and value name are specified. Attempt to interpret
     // the property name as enumerated property.
     const char* property_name = first_part.ToConstVector().start();
     const char* value_name = second_part.ToConstVector().start();
     UProperty property = u_getPropertyEnum(property_name);
     if (!IsExactPropertyAlias(property_name, property)) return false;
     if (property == UCHAR_GENERAL_CATEGORY) {
       // We want to allow aggregate value names such as "Letter".
       property = UCHAR_GENERAL_CATEGORY_MASK;
     } else if (property != UCHAR_SCRIPT &&
                property != UCHAR_SCRIPT_EXTENSIONS) {
       return false;
     }
-    return LookupPropertyValueName(property, value_name, negate, result,
-                                   zone());
+    return LookupPropertyName(property, value_name, negate, result, zone());
   }
 }
 
 #else  // V8_I18N_SUPPORT
 
 bool RegExpParser::ParsePropertyClass(ZoneList<CharacterRange>* result,
                                       bool negate) {
   return false;
 }
 
@@ skipping 587 matching lines @@
     return false;
   }
   terms_.Add(new (zone()) RegExpQuantifier(min, max, quantifier_type, atom),
              zone());
   LAST(ADD_TERM);
   return true;
 }
 
 }  // namespace internal
 }  // namespace v8