Make isolate.h usable without objects-inl.h header.

src/contexts.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_CONTEXTS_H_
 #define V8_CONTEXTS_H_
 
 #include "src/heap/heap.h"
 #include "src/objects.h"
 
@@ skipping 281 matching lines @@
   NATIVE_CONTEXT_IMPORTED_FIELDS(V)
 
 // A table of all script contexts. Every loaded top-level script with top-level
 // lexical declarations contributes its ScriptContext into this table.
 //
 // The table is a fixed array, its first slot is the current used count and
 // the subsequent slots 1..used contain ScriptContexts.
 class ScriptContextTable : public FixedArray {
  public:
   // Conversions.
-  static ScriptContextTable* cast(Object* context) {
-    DCHECK(context->IsScriptContextTable());
-    return reinterpret_cast<ScriptContextTable*>(context);
-  }
+  static inline ScriptContextTable* cast(Object* context);
 
   struct LookupResult {
     int context_index;
     int slot_index;
     VariableMode mode;
     VariableLocation location;
     InitializationFlag init_flag;
     MaybeAssignedFlag maybe_assigned_flag;
   };
 
-  int used() const { return Smi::cast(get(kUsedSlot))->value(); }
-  void set_used(int used) { set(kUsedSlot, Smi::FromInt(used)); }
+  inline int used() const;
+  inline void set_used(int used);
 
-  static Handle<Context> GetContext(Handle<ScriptContextTable> table, int i) {
-    DCHECK(i < table->used());
-    return Handle<Context>::cast(FixedArray::get(table, i + kFirstContextSlot));
-  }
+  static inline Handle<Context> GetContext(Handle<ScriptContextTable> table,
+                                           int i);
 
   // Lookup a variable `name` in a ScriptContextTable.
   // If it returns true, the variable is found and `result` contains
   // valid information about its location.
   // If it returns false, `result` is untouched.
   MUST_USE_RESULT
   static bool Lookup(Handle<ScriptContextTable> table, Handle<String> name,
                      LookupResult* result);
 
   MUST_USE_RESULT
@@ skipping 59 matching lines @@
 // properties.
 //
 // Finally, with Harmony scoping, the JSFunction representing a top level
 // script will have the ScriptContext rather than a FunctionContext.
 // Script contexts from all top-level scripts are gathered in
 // ScriptContextTable.
 
 class Context: public FixedArray {
  public:
   // Conversions.
-  static Context* cast(Object* context) {
-    DCHECK(context->IsContext());
-    return reinterpret_cast<Context*>(context);
-  }
+  static inline Context* cast(Object* context);
 
   // The default context slot layout; indices are FixedArray slot indices.
   enum {
     // These slots are in all contexts.
     CLOSURE_INDEX,
     PREVIOUS_INDEX,
     // The extension slot is used for either the global object (in global
     // contexts), eval extension object (function contexts), subject of with
     // (with contexts), or the variable name (catch contexts), the serialized
     // scope info (block contexts), or the module instance (module contexts).
@@ skipping 15 matching lines @@
     // Total number of slots.
     NATIVE_CONTEXT_SLOTS,
     FIRST_WEAK_SLOT = OPTIMIZED_FUNCTIONS_LIST,
 
     MIN_CONTEXT_SLOTS = GLOBAL_PROXY_INDEX,
     // This slot holds the thrown value in catch contexts.
     THROWN_OBJECT_INDEX = MIN_CONTEXT_SLOTS,
   };
 
   // Direct slot access.
-  JSFunction* closure() { return JSFunction::cast(get(CLOSURE_INDEX)); }
-  void set_closure(JSFunction* closure) { set(CLOSURE_INDEX, closure); }
+  inline JSFunction* closure();
+  inline void set_closure(JSFunction* closure);
 
-  Context* previous() {
-    Object* result = unchecked_previous();
-    DCHECK(IsBootstrappingOrValidParentContext(result, this));
-    return reinterpret_cast<Context*>(result);
-  }
-  void set_previous(Context* context) { set(PREVIOUS_INDEX, context); }
+  inline Context* previous();
+  inline void set_previous(Context* context);
 
-  bool has_extension() { return extension() != nullptr; }
-  Object* extension() { return get(EXTENSION_INDEX); }
-  void set_extension(Object* object) { set(EXTENSION_INDEX, object); }
+  inline bool has_extension();
+  inline Object* extension();
+  inline void set_extension(Object* object);
   JSObject* extension_object();
   JSReceiver* extension_receiver();
   ScopeInfo* scope_info();
   String* catch_name();
 
-  JSModule* module() { return JSModule::cast(get(EXTENSION_INDEX)); }
-  void set_module(JSModule* module) { set(EXTENSION_INDEX, module); }
+  inline JSModule* module();
+  inline void set_module(JSModule* module);
 
   // Get the context where var declarations will be hoisted to, which
   // may be the context itself.
   Context* declaration_context();
   bool is_declaration_context();
 
-  GlobalObject* global_object() {
-    Object* result = get(GLOBAL_OBJECT_INDEX);
-    DCHECK(IsBootstrappingOrGlobalObject(this->GetIsolate(), result));
-    return reinterpret_cast<GlobalObject*>(result);
-  }
-  void set_global_object(GlobalObject* object) {
-    set(GLOBAL_OBJECT_INDEX, object);
-  }
+  inline GlobalObject* global_object();
+  inline void set_global_object(GlobalObject* object);
 
   // Returns a JSGlobalProxy object or null.
   JSObject* global_proxy();
   void set_global_proxy(JSObject* global);
 
   // The builtins object.
   JSBuiltinsObject* builtins();
 
   // Get the script context by traversing the context chain.
   Context* script_context();
 
   // Compute the native context by traversing the context chain.
   Context* native_context();
 
   // Predicates for context types.  IsNativeContext is also defined on Object
   // because we frequently have to know if arbitrary objects are natives
   // contexts.
-  bool IsNativeContext() {
-    Map* map = this->map();
-    return map == map->GetHeap()->native_context_map();
-  }
-  bool IsFunctionContext() {
-    Map* map = this->map();
-    return map == map->GetHeap()->function_context_map();
-  }
-  bool IsCatchContext() {
-    Map* map = this->map();
-    return map == map->GetHeap()->catch_context_map();
-  }
-  bool IsWithContext() {
-    Map* map = this->map();
-    return map == map->GetHeap()->with_context_map();
-  }
-  bool IsBlockContext() {
-    Map* map = this->map();
-    return map == map->GetHeap()->block_context_map();
-  }
-  bool IsModuleContext() {
-    Map* map = this->map();
-    return map == map->GetHeap()->module_context_map();
-  }
-  bool IsScriptContext() {
-    Map* map = this->map();
-    return map == map->GetHeap()->script_context_map();
-  }
+  inline bool IsNativeContext();
+  inline bool IsFunctionContext();
+  inline bool IsCatchContext();
+  inline bool IsWithContext();
+  inline bool IsBlockContext();
+  inline bool IsModuleContext();
+  inline bool IsScriptContext();
 
-  bool HasSameSecurityTokenAs(Context* that) {
-    return this->global_object()->native_context()->security_token() ==
-        that->global_object()->native_context()->security_token();
-  }
+  inline bool HasSameSecurityTokenAs(Context* that);
 
   // Initializes global variable bindings in given script context.
   void InitializeGlobalSlots();
 
   // A native context holds a list of all functions with optimized code.
   void AddOptimizedFunction(JSFunction* function);
   void RemoveOptimizedFunction(JSFunction* function);
   void SetOptimizedFunctionsListHead(Object* head);
   Object* OptimizedFunctionsListHead();
 
   // The native context also stores a list of all optimized code and a
   // list of all deoptimized code, which are needed by the deoptimizer.
   void AddOptimizedCode(Code* code);
   void SetOptimizedCodeListHead(Object* head);
   Object* OptimizedCodeListHead();
   void SetDeoptimizedCodeListHead(Object* head);
   Object* DeoptimizedCodeListHead();
 
   Handle<Object> ErrorMessageForCodeGenerationFromStrings();
 
   static int ImportedFieldIndexForName(Handle<String> name);
   static int IntrinsicIndexForName(Handle<String> name);
 
   static bool IsJSBuiltin(Handle<Context> native_context,
                           Handle<JSFunction> function);
 
 #define NATIVE_CONTEXT_FIELD_ACCESSORS(index, type, name) \
-  void  set_##name(type* value) {                         \
-    DCHECK(IsNativeContext());                            \
-    set(index, value);                                    \
-  }                                                       \
-  bool is_##name(type* value) {                           \
-    DCHECK(IsNativeContext());                            \
-    return type::cast(get(index)) == value;               \
-  }                                                       \
-  type* name() {                                          \
-    DCHECK(IsNativeContext());                            \
-    return type::cast(get(index));                        \
-  }
+  inline void set_##name(type* value);                    \
+  inline bool is_##name(type* value);                     \
+  inline type* name();
   NATIVE_CONTEXT_FIELDS(NATIVE_CONTEXT_FIELD_ACCESSORS)
 #undef NATIVE_CONTEXT_FIELD_ACCESSORS
 
   // Lookup the slot called name, starting with the current context.
   // There are three possibilities:
   //
   // 1) result->IsContext():
   //    The binding was found in a context.  *index is always the
   //    non-negative slot index.  *attributes is NONE for var and let
   //    declarations, READ_ONLY for const declarations (never ABSENT).
@@ skipping 49 matching lines @@
   // GC support.
   typedef FixedBodyDescriptor<
       kHeaderSize, kSize, kSize> ScavengeBodyDescriptor;
 
   typedef FixedBodyDescriptor<
       kHeaderSize,
       kHeaderSize + FIRST_WEAK_SLOT * kPointerSize,
       kSize> MarkCompactBodyDescriptor;
 
  private:
-  // Unchecked access to the slots.
-  Object* unchecked_previous() { return get(PREVIOUS_INDEX); }
-
 #ifdef DEBUG
   // Bootstrapping-aware type checks.
   static bool IsBootstrappingOrValidParentContext(Object* object, Context* kid);
   static bool IsBootstrappingOrGlobalObject(Isolate* isolate, Object* object);
 #endif
 
   STATIC_ASSERT(kHeaderSize == Internals::kContextHeaderSize);
   STATIC_ASSERT(EMBEDDER_DATA_INDEX == Internals::kContextEmbedderDataIndex);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CONTEXTS_H_