Split --harmony-unicode and --harmony-unicode-regexps.

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 4597 matching lines @@
           }
           RegExpTree* atom = new(zone()) RegExpBackReference(capture);
           builder->AddAtom(atom);
           break;
         }
         uc32 first_digit = Next();
         if (first_digit == '8' || first_digit == '9') {
           // If the 'u' flag is present, only syntax characters can be escaped,
           // no other identity escapes are allowed. If the 'u' flag is not
           // present, all identity escapes are allowed.
-          if (!FLAG_harmony_unicode || !unicode_) {
+          if (!FLAG_harmony_unicode_regexps || !unicode_) {
             builder->AddCharacter(first_digit);
             Advance(2);
           } else {
             return ReportError(CStrVector("Invalid escape"));
           }
           break;
         }
       }
       // FALLTHROUGH
       case '0': {
@@ skipping 40 matching lines @@
           Advance(2);
           builder->AddCharacter(controlLetter & 0x1f);
         }
         break;
       }
       case 'x': {
         Advance(2);
         uc32 value;
         if (ParseHexEscape(2, &value)) {
           builder->AddCharacter(value);
-        } else if (!FLAG_harmony_unicode || !unicode_) {
+        } else if (!FLAG_harmony_unicode_regexps || !unicode_) {
           builder->AddCharacter('x');
         } else {
           // 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)) {
           builder->AddCharacter(value);
-        } else if (!FLAG_harmony_unicode || !unicode_) {
+        } 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:
         Advance();
         // If the 'u' flag is present, only syntax characters can be escaped, no
         // other identity escapes are allowed. If the 'u' flag is not present,
         // all identity escapes are allowed.
-        if (!FLAG_harmony_unicode || !unicode_ ||
+        if (!FLAG_harmony_unicode_regexps || !unicode_ ||
             IsSyntaxCharacter(current())) {
           builder->AddCharacter(current());
           Advance();
         } else {
           return ReportError(CStrVector("Invalid escape"));
         }
         break;
       }
       break;
     case '{': {
@@ skipping 250 matching lines @@
   }
   *value = val;
   return true;
 }
 
 
 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() == '{' && FLAG_harmony_unicode && unicode_) {
+  if (current() == '{' && FLAG_harmony_unicode_regexps && unicode_) {
     int start = position();
     Advance();
     if (ParseUnlimitedLengthHexNumber(0x10ffff, value)) {
       if (current() == '}') {
         Advance();
         return true;
       }
     }
     Reset(start);
     return false;
@@ skipping 69 matching lines @@
       // 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.
       return ParseOctalLiteral();
     case 'x': {
       Advance();
       uc32 value;
       if (ParseHexEscape(2, &value)) {
         return value;
       }
-      if (!FLAG_harmony_unicode || !unicode_) {
+      if (!FLAG_harmony_unicode_regexps || !unicode_) {
         // If \x is not followed by a two-digit hexadecimal, treat it
         // as an identity escape.
         return 'x';
       }
       // If the 'u' flag is present, invalid escapes are not treated as
       // identity escapes.
       ReportError(CStrVector("Invalid escape"));
       return 0;
     }
     case 'u': {
       Advance();
       uc32 value;
       if (ParseUnicodeEscape(&value)) {
         return value;
       }
-      if (!FLAG_harmony_unicode || !unicode_) {
+      if (!FLAG_harmony_unicode_regexps || !unicode_) {
         return 'u';
       }
       // If the 'u' flag is present, invalid escapes are not treated as
       // identity escapes.
       ReportError(CStrVector("Invalid unicode escape"));
       return 0;
     }
     default: {
       uc32 result = current();
       // If the 'u' flag is present, only syntax characters can be escaped, no
       // other identity escapes are allowed. If the 'u' flag is not present, all
       // identity escapes are allowed.
-      if (!FLAG_harmony_unicode || !unicode_ || IsSyntaxCharacter(result)) {
+      if (!FLAG_harmony_unicode_regexps || !unicode_ ||
+          IsSyntaxCharacter(result)) {
         Advance();
         return result;
       }
       ReportError(CStrVector("Invalid escape"));
       return 0;
     }
   }
   return 0;
 }
 
@@ skipping 304 matching lines @@
     } else {
       const uc16* data = reinterpret_cast<const uc16*>(raw_string->raw_data());
       running_hash = StringHasher::ComputeRunningHash(running_hash, data,
                                                       raw_string->length());
     }
   }
 
   return running_hash;
 }
 } }  // namespace v8::internal