[regexp] support \p in character classes.

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 340 matching lines @@
             RegExpCharacterClass* cc =
                 new (zone()) RegExpCharacterClass(ranges, false);
             builder->AddCharacterClass(cc);
             break;
           }
           case 'p':
           case 'P': {
             uc32 p = Next();
             Advance(2);
             if (unicode()) {
-              ZoneList<CharacterRange>* ranges = ParsePropertyClass();
-              if (ranges == nullptr) {
-                return ReportError(CStrVector("Invalid property name"));
+              if (FLAG_harmony_regexp_property) {
+                ZoneList<CharacterRange>* ranges =
+                    new (zone()) ZoneList<CharacterRange>(2, zone());
+                if (!ParsePropertyClass(ranges)) {
+                  return ReportError(CStrVector("Invalid property name"));
+                }
+                RegExpCharacterClass* cc =
+                    new (zone()) RegExpCharacterClass(ranges, p == 'P');
+                builder->AddCharacterClass(cc);
+              } else {
+                // With /u, no identity escapes except for syntax characters
+                // are allowed. Otherwise, all identity escapes are allowed.
+                return ReportError(CStrVector("Invalid escape"));
               }
-              RegExpCharacterClass* cc =
-                  new (zone()) RegExpCharacterClass(ranges, p == 'P');
-              builder->AddCharacterClass(cc);
             } else {
               builder->AddCharacter(p);
             }
             break;
           }
           case '1':
           case '2':
           case '3':
           case '4':
           case '5':
@@ skipping 451 matching lines @@
         *value = unibrow::Utf16::CombineSurrogatePair(static_cast<uc16>(*value),
                                                       static_cast<uc16>(trail));
         return true;
       }
     }
     Reset(start);
   }
   return result;
 }
 
-ZoneList<CharacterRange>* RegExpParser::ParsePropertyClass() {
+bool RegExpParser::ParsePropertyClass(ZoneList<CharacterRange>* result) {
 #ifdef V8_I18N_SUPPORT
   ZoneList<char> property_name(0, zone());
   if (current() == '{') {
     for (Advance(); current() != '}'; Advance()) {
-      if (!has_next()) return nullptr;
+      if (!has_next()) return false;
       property_name.Add(static_cast<char>(current()), zone());
     }
   } else if (current() != kEndMarker) {
     property_name.Add(static_cast<char>(current()), zone());
   } else {
-    return nullptr;
+    return false;
   }
   Advance();
   property_name.Add(0, zone());  // null-terminate string.
 
   // Property names are defined in unicode database files. For aliases of
   // these property names, see PropertyValueAliases.txt.
   UProperty kPropertyClasses[] = {
       // General_Category (gc) found in PropertyValueAliases.txt
       UCHAR_GENERAL_CATEGORY_MASK,
       // Script (sc) found in Scripts.txt
       UCHAR_SCRIPT,
   };
 
   for (int i = 0; i < arraysize(kPropertyClasses); i++) {
     UProperty property_class = kPropertyClasses[i];
     int32_t category = u_getPropertyValueEnum(
         property_class, property_name.ToConstVector().start());
     if (category == UCHAR_INVALID_CODE) continue;
 
     USet* set = uset_openEmpty();
     UErrorCode ec = U_ZERO_ERROR;
     uset_applyIntPropertyValue(set, property_class, category, &ec);
-    ZoneList<CharacterRange>* ranges = nullptr;
     if (ec == U_ZERO_ERROR && !uset_isEmpty(set)) {
       uset_removeAllStrings(set);
       int item_count = uset_getItemCount(set);
-      ranges = new (zone()) ZoneList<CharacterRange>(item_count, zone());
       int item_result = 0;
       for (int i = 0; i < item_count; i++) {
         uc32 start = 0;
         uc32 end = 0;
         item_result += uset_getItem(set, i, &start, &end, nullptr, 0, &ec);
-        ranges->Add(CharacterRange::Range(start, end), zone());
+        result->Add(CharacterRange::Range(start, end), zone());
       }
       DCHECK_EQ(U_ZERO_ERROR, ec);
       DCHECK_EQ(0, item_result);
     }
     uset_close(set);
-    return ranges;
+    return true;
   }
 #endif  // V8_I18N_SUPPORT
 
-  return nullptr;
+  return false;
 }
 
 bool RegExpParser::ParseUnlimitedLengthHexNumber(int max_value, uc32* value) {
   uc32 x = 0;
   int d = HexValue(current());
   if (d < 0) {
     return false;
   }
   while (d >= 0) {
     x = x * 16 + d;
@@ skipping 159 matching lines @@
 static inline void AddRangeOrEscape(ZoneList<CharacterRange>* ranges,
                                     uc16 char_class, CharacterRange range,
                                     Zone* zone) {
   if (char_class != kNoCharClass) {
     CharacterRange::AddClassEscape(char_class, ranges, zone);
   } else {
     ranges->Add(range, zone);
   }
 }
 
+bool RegExpParser::ParseClassProperty(ZoneList<CharacterRange>* ranges) {
+  if (!FLAG_harmony_regexp_property) return false;
+  if (!unicode()) return false;
+  if (current() != '\\') return false;
+  uc32 next = Next();
+  bool parse_success = false;
+  if (next == 'p') {
+    Advance(2);
+    parse_success = ParsePropertyClass(ranges);
+  } else if (next == 'P') {
+    Advance(2);
+    ZoneList<CharacterRange>* property_class =
+        new (zone()) ZoneList<CharacterRange>(2, zone());
+    parse_success = ParsePropertyClass(property_class);
+    if (parse_success) {
+      ZoneList<CharacterRange>* negated =
+          new (zone()) ZoneList<CharacterRange>(2, zone());
+      CharacterRange::Negate(property_class, negated, zone());
+      const Vector<CharacterRange> negated_vector = negated->ToVector();
+      ranges->AddAll(negated_vector, zone());
+    }
+  } else {
+    return false;
+  }
+  if (!parse_success)
+    ReportError(CStrVector("Invalid property name in character class"));
+  return parse_success;
+}
 
 RegExpTree* RegExpParser::ParseCharacterClass() {
   static const char* kUnterminated = "Unterminated character class";
   static const char* kRangeInvalid = "Invalid character class";
   static const char* kRangeOutOfOrder = "Range out of order in character class";
 
   DCHECK_EQ(current(), '[');
   Advance();
   bool is_negated = false;
   if (current() == '^') {
     is_negated = true;
     Advance();
   }
   ZoneList<CharacterRange>* ranges =
       new (zone()) ZoneList<CharacterRange>(2, zone());
   while (has_more() && current() != ']') {
+    bool parsed_property = ParseClassProperty(ranges CHECK_FAILED);
+    if (parsed_property) continue;
     uc16 char_class = kNoCharClass;
     CharacterRange first = ParseClassAtom(&char_class CHECK_FAILED);
     if (current() == '-') {
       Advance();
       if (current() == kEndMarker) {
         // If we reach the end we break out of the loop and let the
         // following code report an error.
         break;
       } else if (current() == ']') {
         AddRangeOrEscape(ranges, char_class, first, zone());
@@ skipping 351 matching lines @@
     return false;
   }
   terms_.Add(new (zone()) RegExpQuantifier(min, max, quantifier_type, atom),
              zone());
   LAST(ADD_TERM);
   return true;
 }
 
 }  // namespace internal
 }  // namespace v8