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

src/regexp/regexp-parser.h

 // 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.
 
 #ifndef V8_REGEXP_REGEXP_PARSER_H_
 #define V8_REGEXP_REGEXP_PARSER_H_
 
 #include "src/objects.h"
 #include "src/regexp/regexp-ast.h"
 #include "src/zone/zone.h"
@@ skipping 166 matching lines @@
   bool ParsePropertyClass(ZoneList<CharacterRange>* result, bool negate);
 
   uc32 ParseOctalLiteral();
 
   // Tries to parse the input as a back reference.  If successful it
   // stores the result in the output parameter and returns true.  If
   // it fails it will push back the characters read so the same characters
   // can be reparsed.
   bool ParseBackReferenceIndex(int* index_out);
 
+  // The default behavior is to combine surrogate pairs in unicode mode and
+  // don't combine them otherwise (a quantifier after a surrogate pair would
+  // then apply only to the trailing surrogate). Forcing combination is required
+  // when parsing capture names since they can always legally contain surrogate
+  // pairs.
+  enum class ScanMode { DEFAULT, FORCE_COMBINE_SURROGATE_PAIRS };
+
   bool ParseClassProperty(ZoneList<CharacterRange>* result);
   CharacterRange ParseClassAtom(uc16* char_class);
   RegExpTree* ReportError(Vector<const char> message);
-  void Advance();
-  void Advance(int dist);
+  void Advance(ScanMode mode = ScanMode::DEFAULT);
+  void Advance(int dist, ScanMode mode = ScanMode::DEFAULT);
   void Reset(int pos);
 
   // Reports whether the pattern might be used as a literal search string.
   // Only use if the result of the parse is a single atom node.
   bool simple();
   bool contains_anchor() { return contains_anchor_; }
   void set_contains_anchor() { contains_anchor_ = true; }
   int captures_started() { return captures_started_; }
   int position() { return next_pos_ - 1; }
   bool failed() { return failed_; }
@@ skipping 95 matching lines @@
   // ScanForCaptures to look ahead at the remaining pattern.
   bool HasNamedCaptures();
 
   Isolate* isolate() { return isolate_; }
   Zone* zone() const { return zone_; }
 
   uc32 current() { return current_; }
   bool has_more() { return has_more_; }
   bool has_next() { return next_pos_ < in()->length(); }
   uc32 Next();
-  template <bool update_position>
-  uc32 ReadNext();
+  uc32 ReadNext(bool update_position, ScanMode mode);
   FlatStringReader* in() { return in_; }
   void ScanForCaptures();
 
   Isolate* isolate_;
   Zone* zone_;
   Handle<String>* error_;
   ZoneList<RegExpCapture*>* captures_;
   ZoneList<RegExpCapture*>* named_captures_;
   ZoneList<RegExpBackReference*>* named_back_references_;
   FlatStringReader* in_;
@@ skipping 10 matching lines @@
   bool contains_anchor_;
   bool is_scanned_for_captures_;
   bool has_named_captures_;  // Only valid after we have scanned for captures.
   bool failed_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_REGEXP_REGEXP_PARSER_H_