[regexp] simplify unicode flag check.

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 325 matching lines @@
                 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_regexps || !unicode_) {
+              if (!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_regexps || !unicode_) {
+            } else if (!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_regexps || !unicode_) {
+            } else if (!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_regexps || !unicode_ ||
-                IsSyntaxCharacter(current())) {
+            if (!unicode_ || IsSyntaxCharacter(current())) {
               builder->AddCharacter(current());
               Advance();
             } else {
               return ReportError(CStrVector("Invalid escape"));
             }
             break;
         }
         break;
       case '{': {
         int dummy;
@@ skipping 280 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_regexps && unicode_) {
+  if (current() == '{' && unicode_) {
     int start = position();
     Advance();
     if (ParseUnlimitedLengthHexNumber(0x10ffff, value)) {
       if (current() == '}') {
         Advance();
         return true;
       }
     }
     Reset(start);
     return false;
@@ skipping 74 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_regexps || !unicode_) {
+      if (!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_regexps || !unicode_) {
+      if (!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_regexps || !unicode_ ||
-          IsSyntaxCharacter(result)) {
+      if (!unicode_ || IsSyntaxCharacter(result)) {
         Advance();
         return result;
       }
       ReportError(CStrVector("Invalid escape"));
       return 0;
     }
   }
   return 0;
 }
 
@@ skipping 270 matching lines @@
     UNREACHABLE();
     return;
   }
   terms_.Add(new (zone()) RegExpQuantifier(min, max, quantifier_type, atom),
              zone());
   LAST(ADD_TERM);
 }
 
 }  // namespace internal
 }  // namespace v8