[regexp] quantifier refers to the surrogate pair in unicode regexp.

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 38 matching lines @@
 void RegExpParser::Advance() {
   if (next_pos_ < in()->length()) {
     StackLimitCheck check(isolate());
     if (check.HasOverflowed()) {
       ReportError(CStrVector(Isolate::kStackOverflowMessage));
     } else if (zone()->excess_allocation()) {
       ReportError(CStrVector("Regular expression too large"));
     } else {
       current_ = in()->Get(next_pos_);
       next_pos_++;
+      // Read the whole surrogate pair in case of unicode flag, if possible.
+      if (unicode_ && next_pos_ < in()->length() &&
+          unibrow::Utf16::IsLeadSurrogate(static_cast<uc16>(current_))) {
+        uc16 trail = in()->Get(next_pos_);
+        if (unibrow::Utf16::IsTrailSurrogate(trail)) {
+          current_ = unibrow::Utf16::CombineSurrogatePair(
+              static_cast<uc16>(current_), trail);
+          next_pos_++;
+        }
+      }
     }
   } 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;
   }
 }
 
@@ skipping 341 matching lines @@
               // If the 'u' flag is present, invalid escapes are not treated as
               // identity escapes.
               return ReportError(CStrVector("Invalid escape"));
             }
             break;
           }
           case 'u': {
             Advance(2);
             uc32 value;
             if (ParseUnicodeEscape(&value)) {
-              if (value > unibrow::Utf16::kMaxNonSurrogateCharCode) {
-                builder->AddCharacter(unibrow::Utf16::LeadSurrogate(value));
-                builder->AddCharacter(unibrow::Utf16::TrailSurrogate(value));
-              } else {
-                builder->AddCharacter(static_cast<uc16>(value));
-              }
+              builder->AddUnicodeCharacter(value);
             } else if (!FLAG_harmony_unicode_regexps || !unicode_) {
               builder->AddCharacter('u');
             } else {
               // If the 'u' flag is present, invalid escapes are not treated as
               // identity escapes.
               return ReportError(CStrVector("Invalid unicode escape"));
             }
             break;
           }
           default:
@@ skipping 14 matching lines @@
         }
         break;
       case '{': {
         int dummy;
         if (ParseIntervalQuantifier(&dummy, &dummy)) {
           ReportError(CStrVector("Nothing to repeat") CHECK_FAILED);
         }
         // fallthrough
       }
       default:
-        builder->AddCharacter(current());
+        if (unicode_) {

[rossberg, 2016/01/11 12:25:41]

Nit: is this if necessary? Can't you always use AddUnicode?

[Yang, 2016/01/11 14:41:44]

Good point. Done.

+          builder->AddUnicodeCharacter(current());
+        } else {
+          builder->AddCharacter(current());
+        }
         Advance();
         break;
     }  // end switch(current())
 
     int min;
     int max;
     switch (current()) {
       // QuantifierPrefix ::
       //   *
       //   +
@@ skipping 581 matching lines @@
 void RegExpBuilder::AddCharacter(uc16 c) {
   pending_empty_ = false;
   if (characters_ == NULL) {
     characters_ = new (zone()) ZoneList<uc16>(4, zone());
   }
   characters_->Add(c, zone());
   LAST(ADD_CHAR);
 }
 
 
+void RegExpBuilder::AddUnicodeCharacter(uc32 c) {
+  if (c > unibrow::Utf16::kMaxNonSurrogateCharCode) {
+    ZoneList<uc16> surrogate_pair(2, zone());
+    surrogate_pair.Add(unibrow::Utf16::LeadSurrogate(c), zone());
+    surrogate_pair.Add(unibrow::Utf16::TrailSurrogate(c), zone());
+    RegExpAtom* atom = new (zone()) RegExpAtom(surrogate_pair.ToConstVector());
+    AddAtom(atom);
+  } else {
+    AddCharacter(static_cast<uc16>(c));
+  }
+}
+
+
 void RegExpBuilder::AddEmpty() { pending_empty_ = true; }
 
 
 void RegExpBuilder::AddAtom(RegExpTree* term) {
   if (term->IsEmpty()) {
     AddEmpty();
     return;
   }
   if (term->IsTextElement()) {
     FlushCharacters();
@@ skipping 83 matching lines @@
     UNREACHABLE();
     return;
   }
   terms_.Add(new (zone()) RegExpQuantifier(min, max, quantifier_type, atom),
              zone());
   LAST(ADD_TERM);
 }
 
 }  // namespace internal
 }  // namespace v8