Add strong mode.

src/globals.h

 // 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.
 
 #ifndef V8_GLOBALS_H_
 #define V8_GLOBALS_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 209 matching lines @@
 class FreeStoreAllocationPolicy;
 template <typename T, class P = FreeStoreAllocationPolicy> class List;
 
 // -----------------------------------------------------------------------------
 // Declarations for use in both the preparser and the rest of V8.
 
 // The Strict Mode (ECMA-262 5th edition, 4.2.2).
 
 enum LanguageMode {
   // LanguageMode is expressed as a bitmask. Descriptions of the bits:
-  STRICT = 1 << 0,
+  STRICT_BIT = 1 << 0,
+  SANE_BIT = 1 << 1,
   LANGUAGE_END,
 
   // Shorthands for some common language modes.
-  SLOPPY = 0
+  SLOPPY = 0,
+  STRICT = STRICT_BIT,
+  SANE = STRICT_BIT | SANE_BIT
 };
 
 inline bool is_strict(LanguageMode language_mode) {
-  return language_mode & STRICT;
+  return language_mode & STRICT_BIT;
 }
 
+
 inline bool is_sloppy(LanguageMode language_mode) {

[rossberg, 2015/02/04 16:18:08]

Nit: perhaps reorder methods.

[marja, 2015/02/05 12:11:37]

Done.

-  return (language_mode & STRICT) == 0;
+  return (language_mode & STRICT_BIT) == 0;
 }
 
+
+inline bool is_sane(LanguageMode language_mode) {
+  return language_mode & SANE_BIT;
+}
+
+
 inline bool is_valid_language_mode(int language_mode) {
-  return language_mode == SLOPPY || language_mode == STRICT;
+  return language_mode == SLOPPY || language_mode == STRICT ||
+         language_mode == SANE;
 }
 
+
+inline LanguageMode construct_language_mode(bool strict_bit, bool sane_bit) {
+  int language_mode = 0;
+  if (strict_bit) language_mode |= STRICT_BIT;
+  if (sane_bit) language_mode |= SANE_BIT;
+  DCHECK(is_valid_language_mode(language_mode));
+  return static_cast<LanguageMode>(language_mode);
+}
+
+
 // Mask for the sign bit in a smi.
 const intptr_t kSmiSignMask = kIntptrSignBit;
 
 const int kObjectAlignmentBits = kPointerSizeLog2;
 const intptr_t kObjectAlignment = 1 << kObjectAlignmentBits;
 const intptr_t kObjectAlignmentMask = kObjectAlignment - 1;
 
 // Desired alignment for pointers.
 const intptr_t kPointerAlignment = (1 << kPointerSizeLog2);
 const intptr_t kPointerAlignmentMask = kPointerAlignment - 1;
@@ skipping 578 matching lines @@
 
 inline bool IsSubclassConstructor(FunctionKind kind) {
   DCHECK(IsValidFunctionKind(kind));
   return kind & FunctionKind::kSubclassConstructor;
 }
 } }  // namespace v8::internal
 
 namespace i = v8::internal;
 
 #endif  // V8_GLOBALS_H_