[regexp] Support unicode capture names in non-unicode patterns

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 28 matching lines @@
       has_more_(true),
       simple_(false),
       contains_anchor_(false),
       is_scanned_for_captures_(false),
       has_named_captures_(false),
       failed_(false) {
   DCHECK_IMPLIES(dotall(), FLAG_harmony_regexp_dotall);
   Advance();
 }
 
-template <bool update_position>
-inline uc32 RegExpParser::ReadNext() {
+inline uc32 RegExpParser::ReadNext(bool update_position, ScanMode mode) {
   int position = next_pos_;
   uc32 c0 = in()->Get(position);
   position++;
-  // Read the whole surrogate pair in case of unicode flag, if possible.
-  if (unicode() && position < in()->length() &&
+  const bool try_combine_surrogate_pairs =
+      (unicode() || mode == ScanMode::FORCE_COMBINE_SURROGATE_PAIRS);
+  if (try_combine_surrogate_pairs && position < in()->length() &&
       unibrow::Utf16::IsLeadSurrogate(static_cast<uc16>(c0))) {
     uc16 c1 = in()->Get(position);
     if (unibrow::Utf16::IsTrailSurrogate(c1)) {
       c0 = unibrow::Utf16::CombineSurrogatePair(static_cast<uc16>(c0), c1);
       position++;
     }
   }
   if (update_position) next_pos_ = position;
   return c0;
 }
 
 
 uc32 RegExpParser::Next() {
   if (has_next()) {
-    return ReadNext<false>();
+    return ReadNext(false, ScanMode::DEFAULT);
   } else {
     return kEndMarker;
   }
 }
 
-
-void RegExpParser::Advance() {
+void RegExpParser::Advance(ScanMode mode) {
   if (has_next()) {
     StackLimitCheck check(isolate());
     if (check.HasOverflowed()) {
       if (FLAG_abort_on_stack_overflow) FATAL("Aborting on stack overflow");
       ReportError(CStrVector(
           MessageTemplate::TemplateString(MessageTemplate::kStackOverflow)));
     } else if (zone()->excess_allocation()) {
       ReportError(CStrVector("Regular expression too large"));
     } else {
-      current_ = ReadNext<true>();
+      current_ = ReadNext(true, mode);
     }
   } else {
     current_ = kEndMarker;
     // Advance so that position() points to 1-after-the-last-character. This is
     // important so that Reset() to this position works correctly.
     next_pos_ = in()->length() + 1;
     has_more_ = false;
   }
 }
 
 
 void RegExpParser::Reset(int pos) {
   next_pos_ = pos;
   has_more_ = (pos < in()->length());
   Advance();
 }
 
-
-void RegExpParser::Advance(int dist) {
+void RegExpParser::Advance(int dist, ScanMode mode) {
   next_pos_ += dist - 1;
-  Advance();
+  Advance(mode);
 }
 
 
 bool RegExpParser::simple() { return simple_; }
 
 bool RegExpParser::IsSyntaxCharacterOrSlash(uc32 c) {
   switch (c) {
     case '^':
     case '$':
     case '\\':
@@ skipping 203 matching lines @@
                 } else if (Next() == '!') {
                   subexpr_type = NEGATIVE_LOOKAROUND;
                   lookaround_type = RegExpLookaround::LOOKBEHIND;
                   Advance(2);
                   break;
                 }
               }
               if (FLAG_harmony_regexp_named_captures) {
                 has_named_captures_ = true;
                 is_named_capture = true;
-                Advance();
                 break;
               }
             // Fall through.
             default:
               return ReportError(CStrVector("Invalid group"));
           }
         }
 
         const ZoneVector<uc16>* capture_name = nullptr;
         if (subexpr_type == CAPTURE) {
@@ skipping 419 matching lines @@
   if (code_unit <= unibrow::Utf16::kMaxNonSurrogateCharCode) {
     v->push_back(code_unit);
   } else {
     v->push_back(unibrow::Utf16::LeadSurrogate(code_unit));
     v->push_back(unibrow::Utf16::TrailSurrogate(code_unit));
   }
 }
 
 const ZoneVector<uc16>* RegExpParser::ParseCaptureGroupName() {
   DCHECK(FLAG_harmony_regexp_named_captures);
+  DCHECK_EQ(current(), '<');
 
   ZoneVector<uc16>* name =
       new (zone()->New(sizeof(ZoneVector<uc16>))) ZoneVector<uc16>(zone());
 
+  // Capture names can always contain surrogate pairs, and we need to scan
+  // accordingly.
+  const ScanMode scan_mode = ScanMode::FORCE_COMBINE_SURROGATE_PAIRS;
+  Advance(scan_mode);
+
   bool at_start = true;
   while (true) {
     uc32 c = current();
-    Advance();
+    Advance(scan_mode);
 
     // Convert unicode escapes.
     if (c == '\\' && current() == 'u') {
       // TODO(jgruber): Reconsider this once the spec has settled.
       // https://github.com/tc39/proposal-regexp-named-groups/issues/23
-      Advance();
+      Advance(scan_mode);
       if (!ParseUnicodeEscape(&c)) {
         ReportError(CStrVector("Invalid Unicode escape sequence"));
         return nullptr;
       }
     }
 
     // The backslash char is misclassified as both ID_Start and ID_Continue.
     if (c == '\\') {
       ReportError(CStrVector("Invalid capture group name"));
       return nullptr;
@@ skipping 50 matching lines @@
 }
 
 bool RegExpParser::ParseNamedBackReference(RegExpBuilder* builder,
                                            RegExpParserState* state) {
   // The parser is assumed to be on the '<' in \k<name>.
   if (current() != '<') {
     ReportError(CStrVector("Invalid named reference"));
     return false;
   }
 
-  Advance();
   const ZoneVector<uc16>* name = ParseCaptureGroupName();
   if (name == nullptr) {
     return false;
   }
 
   if (state->IsInsideCaptureGroup(name)) {
     builder->AddEmpty();
   } else {
     RegExpBackReference* atom = new (zone()) RegExpBackReference();
     atom->set_name(name);
@@ skipping 1003 matching lines @@
     return false;
   }
   terms_.Add(new (zone()) RegExpQuantifier(min, max, quantifier_type, atom),
              zone());
   LAST(ADD_TERM);
   return true;
 }
 
 }  // namespace internal
 }  // namespace v8