[regexp] parse RegExpUnicodeEscapeSequence according to spec.

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 443 matching lines @@
             } else {
               // With /u, invalid escapes are not treated as identity escapes.
               return ReportError(CStrVector("Invalid escape"));
             }
             break;
           }
           case 'u': {
             Advance(2);
             uc32 value;
             if (ParseUnicodeEscape(&value)) {
-              builder->AddUnicodeCharacter(value);
+              builder->AddEscapedUnicodeCharacter(value);
             } else if (!unicode()) {
               builder->AddCharacter('u');
             } else {
               // With /u, invalid escapes are not treated as identity escapes.
               return ReportError(CStrVector("Invalid unicode escape"));
             }
             break;
           }
           default:
             Advance();
@@ skipping 298 matching lines @@
       Reset(start);
       return false;
     }
     val = val * 16 + d;
     Advance();
   }
   *value = val;
   return true;
 }
 
-
+// This parses RegExpUnicodeEscapeSequence as described in ECMA262.
 bool RegExpParser::ParseUnicodeEscape(uc32* value) {
   // Accept both \uxxxx and \u{xxxxxx} (if harmony unicode escapes are
   // allowed). In the latter case, the number of hex digits between { } is
   // arbitrary. \ and u have already been read.
   if (current() == '{' && unicode()) {
     int start = position();
     Advance();
     if (ParseUnlimitedLengthHexNumber(0x10ffff, value)) {
       if (current() == '}') {
         Advance();
         return true;
       }
     }
     Reset(start);
     return false;
   }
   // \u but no {, or \u{...} escapes not allowed.
-  return ParseHexEscape(4, value);
+  bool result = ParseHexEscape(4, value);
+  if (result && unicode() && unibrow::Utf16::IsLeadSurrogate(*value) &&
+      current() == '\\') {
+    // Attempt to read trail surrogate.
+    int start = position();
+    if (Next() == 'u') {
+      Advance(2);
+      uc32 trail;
+      if (ParseHexEscape(4, &trail) &&
+          unibrow::Utf16::IsTrailSurrogate(trail)) {
+        *value = unibrow::Utf16::CombineSurrogatePair(static_cast<uc16>(*value),
+                                                      static_cast<uc16>(trail));
+        return true;
+      }
+    }
+    Reset(start);
+  }
+  return result;
 }
 
 
 bool RegExpParser::ParseUnlimitedLengthHexNumber(int max_value, uc32* value) {
   uc32 x = 0;
   int d = HexValue(current());
   if (d < 0) {
     return false;
   }
   while (d >= 0) {
@@ skipping 60 matching lines @@
       return '\\';
     }
     case '0':
     case '1':
     case '2':
     case '3':
     case '4':
     case '5':
     case '6':
     case '7':
-      // For compatibility, we interpret a decimal escape that isn't
-      // a back reference (and therefore either \0 or not valid according
-      // to the specification) as a 1..3 digit octal character code.
       if (unicode()) {
+        // \0 is interpreted as \u0000 if it is not followed by another digit.
+        if (current() == '0') {
+          Advance();
+          if (current() < '0' || current() > '9') return 0;

[Yang, 2016/02/09 19:18:31]

This now matches how we parse \<digit> outside of a character class.

+        }
         // With /u, decimal escape is not interpreted as octal character code.
         ReportError(CStrVector("Invalid class escape"));
         return 0;
       }
+      // For backward compatibility, we interpret escaped digit from 0 to 7 as
+      // a 1..3 digit octal character code.
       return ParseOctalLiteral();
     case 'x': {
       Advance();
       uc32 value;
       if (ParseHexEscape(2, &value)) return value;
       if (unicode()) {
         // With /u, invalid escapes are not treated as identity escapes.
         ReportError(CStrVector("Invalid escape"));
         return 0;
       }
       // If \x is not followed by a two-digit hexadecimal, treat it
       // as an identity escape.
       return 'x';
     }
     case 'u': {
       Advance();
       uc32 value;
       if (ParseUnicodeEscape(&value)) return value;
       if (unicode()) {
         // With /u, invalid escapes are not treated as identity escapes.
         ReportError(CStrVector("Invalid unicode escape"));
         return 0;
       }
       // If \u is not followed by a two-digit hexadecimal, treat it
       // as an identity escape.
       return 'u';
     }
     default: {
       uc32 result = current();
-      // With /u, no identity escapes except for syntax characters are
+      // With /u, no identity escapes except for syntax characters and '-' are
       // allowed. Otherwise, all identity escapes are allowed.
-      if (!unicode() || IsSyntaxCharacterOrSlash(result)) {
+      if (!unicode() || IsSyntaxCharacterOrSlash(result) || result == '-') {
         Advance();
         return result;
       }
       ReportError(CStrVector("Invalid escape"));
       return 0;
     }
   }
   return 0;
 }
 
@@ skipping 15 matching lines @@
       }
       case kEndMarker:
         return ReportError(CStrVector("\\ at end of pattern"));
       default:
         first = ParseClassCharacterEscape(CHECK_FAILED);
     }
   } else {
     Advance();
   }
 
-  if (unicode() && unibrow::Utf16::IsLeadSurrogate(first)) {
-    // Combine with possibly following trail surrogate.
-    int start = position();
-    uc32 second = current();
-    if (second == '\\') {
-      second = ParseClassCharacterEscape(CHECK_FAILED);
-    } else {
-      Advance();
-    }
-    if (unibrow::Utf16::IsTrailSurrogate(second)) {
-      first = unibrow::Utf16::CombineSurrogatePair(first, second);
-    } else {
-      Reset(start);
-    }
-  }
-
   return CharacterRange::Singleton(first);
 }
 
 
 static const uc16 kNoCharClass = 0;
 
 // Adds range or pre-defined character class to character ranges.
 // If char_class is not kInvalidClass, it's interpreted as a class
 // escape (i.e., 's' means whitespace, from '\s').
 static inline void AddRangeOrEscape(ZoneList<CharacterRange>* ranges,
@@ skipping 208 matching lines @@
     AddTrailSurrogate(unibrow::Utf16::TrailSurrogate(c));
   } else if (unicode() && unibrow::Utf16::IsLeadSurrogate(c)) {
     AddLeadSurrogate(c);
   } else if (unicode() && unibrow::Utf16::IsTrailSurrogate(c)) {
     AddTrailSurrogate(c);
   } else {
     AddCharacter(static_cast<uc16>(c));
   }
 }
 
+void RegExpBuilder::AddEscapedUnicodeCharacter(uc32 character) {
+  // A lead or trail surrogate parsed via escape sequence will not
+  // pair up with any preceding lead or following trail surrogate.
+  FlushPendingSurrogate();
+  AddUnicodeCharacter(character);
+  FlushPendingSurrogate();
+}
 
 void RegExpBuilder::AddEmpty() { pending_empty_ = true; }
 
 
 void RegExpBuilder::AddCharacterClass(RegExpCharacterClass* cc) {
   if (NeedsDesugaringForUnicode(cc)) {
     // With /u, character class needs to be desugared, so it
     // must be a standalone term instead of being part of a RegExpText.
     AddTerm(cc);
   } else {
@@ skipping 151 matching lines @@
     return false;
   }
   terms_.Add(new (zone()) RegExpQuantifier(min, max, quantifier_type, atom),
              zone());
   LAST(ADD_TERM);
   return true;
 }
 
 }  // namespace internal
 }  // namespace v8