[regexp] implement latest spec draft for property class.

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 1064 matching lines @@
         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) {
+  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, property_value_name);
+      u_getPropertyValueEnum(property_for_lookup, property_value_name);
   if (property_value == UCHAR_INVALID_CODE) return false;
 
   // We require the property name to match exactly to one of the property value
   // aliases. However, u_getPropertyValueEnum uses loose matching.
-  if (!IsExactPropertyValueAlias(property_value_name, property,
+  if (!IsExactPropertyValueAlias(property_value_name, property_for_lookup,
                                  property_value)) {
     return false;
   }
 
   USet* set = uset_openEmpty();
   UErrorCode ec = U_ZERO_ERROR;
   uset_applyIntPropertyValue(set, property, property_value, &ec);
   bool success = ec == U_ZERO_ERROR && !uset_isEmpty(set);
 
   if (success) {
@@ skipping 87 matching lines @@
     if (property >= UCHAR_BINARY_LIMIT) return false;
     if (!IsExactPropertyAlias(name, property)) return false;
     return LookupPropertyValueName(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 (property < UCHAR_INT_START) return false;
-    if (property >= UCHAR_INT_LIMIT) return false;
+    if (property != UCHAR_SCRIPT && property != UCHAR_SCRIPT_EXTENSIONS) {
+      return false;
+    }

[Dan Ehrenberg, 2016/11/16 17:54:52]

You're removing more than support for blocks here. We might end up adding blocks
back in
(https://github.com/mathiasbynens/es-regexp-unicode-property-escapes/issues/18)
but probably won't add back in every single property ICU supports. Could you add
a test that checks that another random property name is not supported? e.g.,
NFKD_Quick_Check for an especially unlikely one.

     if (!IsExactPropertyAlias(property_name, property)) return false;
     return LookupPropertyValueName(property, value_name, negate, result,
                                    zone());
   }
 }
 
 #else  // V8_I18N_SUPPORT
 
 bool RegExpParser::ParsePropertyClass(ZoneList<CharacterRange>* result,
                                       bool negate) {
@@ skipping 576 matching lines @@
     return false;
   }
   terms_.Add(new (zone()) RegExpQuantifier(min, max, quantifier_type, atom),
              zone());
   LAST(ADD_TERM);
   return true;
 }
 
 }  // namespace internal
 }  // namespace v8