Implement ES6 unicode escapes.

src/parser.cc

 // Copyright 2012 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/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 4461 matching lines @@
         if (ParseHexEscape(2, &value)) {
           builder->AddCharacter(value);
         } else {
           builder->AddCharacter('x');
         }
         break;
       }
       case 'u': {
         Advance(2);
         uc32 value;
-        if (ParseHexEscape(4, &value)) {
+        if (ParseUnicodeEscape(&value)) {
           builder->AddCharacter(value);
         } else {
           builder->AddCharacter('u');
         }
         break;
       }
       default:
         // Identity escape.
         builder->AddCharacter(Next());
         Advance(2);
@@ skipping 232 matching lines @@
     Advance();
     if (value < 32 && '0' <= current() && current() <= '7') {
       value = value * 8 + current() - '0';
       Advance();
     }
   }
   return value;
 }
 
 
-bool RegExpParser::ParseHexEscape(int length, uc32 *value) {
+bool RegExpParser::ParseHexEscape(int length, uc32* value) {
   int start = position();
   uc32 val = 0;
-  bool done = false;
-  for (int i = 0; !done; i++) {
+  for (int i = 0; i < length; ++i) {
     uc32 c = current();
     int d = HexValue(c);
     if (d < 0) {
       Reset(start);
       return false;
     }
     val = val * 16 + d;
     Advance();
-    if (i == length - 1) {
-      done = true;
+  }
+  *value = val;
+  return true;
+}
+
+
+bool RegExpParser::ParseUnicodeEscape(uc32* value) {
+  if (current() == '{') {
+    int start = position();
+    Advance();
+    if (ParseUnlimitedLengthHexEscape(0x10ffff, value)) {
+      if (current() == '}') {
+        Advance();
+        return true;
+      }
+      Reset(start);
+      return false;
+    }
+    // Parsing the hex number failed.
+    Reset(start);
+    return false;
+  }
+  // \u but no {
+  return ParseHexEscape(4, value);
+}
+
+
+bool RegExpParser::ParseUnlimitedLengthHexEscape(int max_value, uc32* value) {
+  int start = position();
+  uc32 val = 0;
+  int d = HexValue(current());
+  if (d < 0) {
+    Reset(start);
+    return false;
+  }
+  while (d >= 0) {
+    val = val * 16 + d;
+    Advance();
+    d = HexValue(current());
+    if (val > max_value) {
+      Reset(start);
+      return false;
     }
   }
   *value = val;
   return true;
 }
 
 
 uc32 RegExpParser::ParseClassCharacterEscape() {
   DCHECK(current() == '\\');
   DCHECK(has_next() && !IsSpecialClassEscape(Next()));
@@ skipping 48 matching lines @@
       if (ParseHexEscape(2, &value)) {
         return value;
       }
       // If \x is not followed by a two-digit hexadecimal, treat it
       // as an identity escape.
       return 'x';
     }
     case 'u': {
       Advance();
       uc32 value;
-      if (ParseHexEscape(4, &value)) {
+      if (ParseUnicodeEscape(&value)) {
+        fprintf(stderr, "worked; returning code point %d\n", value);
         return value;
       }
-      // If \u is not followed by a four-digit hexadecimal, treat it
-      // as an identity escape.
+      // If \u is not followed by a legal hex decimal sequence, treat it as an
+      // identity escape.
       return 'u';
     }
     default: {
       // Extended identity escape. We accept any character that hasn't
       // been matched by a more specific case, not just the subset required
       // by the ECMAScript specification.
       uc32 result = current();
       Advance();
       return result;
     }
@@ skipping 190 matching lines @@
 
   // We cannot internalize on a background thread; a foreground task will take
   // care of calling Parser::Internalize just before compilation.
 
   if (compile_options() == ScriptCompiler::kProduceParserCache) {
     if (result != NULL) *info_->cached_data() = recorder.GetScriptData();
     log_ = NULL;
   }
 }
 } }  // namespace v8::internal