[Isolates] Move contents of Top into Isolate....

src/api.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 22 matching lines @@
 #include "compiler.h"
 #include "debug.h"
 #include "execution.h"
 #include "global-handles.h"
 #include "heap-profiler.h"
 #include "messages.h"
 #include "platform.h"
 #include "profile-generator-inl.h"
 #include "serialize.h"
 #include "snapshot.h"
-#include "top.h"
 #include "utils.h"
 #include "v8threads.h"
 #include "version.h"
 
 #include "../include/v8-profiler.h"
 
 #define LOG_API(expr) LOG(ApiEntryCall(expr))
 
 #ifdef ENABLE_VMSTATE_TRACKING
 #define ENTER_V8 i::VMState __state__(i::OTHER)
 #define LEAVE_V8 i::VMState __state__(i::EXTERNAL)
 #else
 #define ENTER_V8 ((void) 0)
 #define LEAVE_V8 ((void) 0)
 #endif
 
 namespace v8 {
 
 #define ON_BAILOUT(location, code)                                 \
   if (IsDeadCheck(location) || v8::V8::IsExecutionTerminating()) { \
     code;                                                          \
     UNREACHABLE();                                                 \
   }
 
 
 #define EXCEPTION_PREAMBLE()                                      \
   i::Isolate* isolate = i::Isolate::Current();                    \
   isolate->handle_scope_implementer()->IncrementCallDepth();      \
-  ASSERT(!i::Top::external_caught_exception());                   \
+  ASSERT(!isolate->external_caught_exception());                  \
   bool has_pending_exception = false
 
 
 #define EXCEPTION_BAILOUT_CHECK(value)                                         \
   do {                                                                         \
     i::HandleScopeImplementer* handle_scope_implementer =                      \
         isolate->handle_scope_implementer();                                   \
     handle_scope_implementer->DecrementCallDepth();                            \
     if (has_pending_exception) {                                               \
       if (handle_scope_implementer->CallDepthIsZero() &&                       \
-          i::Top::is_out_of_memory()) {                                        \
+          i::Isolate::Current()->is_out_of_memory()) {                         \
         if (!handle_scope_implementer->ignore_out_of_memory())                 \
           i::V8::FatalProcessOutOfMemory(NULL);                                \
       }                                                                        \
       bool call_depth_is_zero = handle_scope_implementer->CallDepthIsZero();   \
-      i::Top::OptionalRescheduleException(call_depth_is_zero);                 \
+      i::Isolate::Current()->OptionalRescheduleException(call_depth_is_zero);  \
       return value;                                                            \
     }                                                                          \
   } while (false)
 
 
 #define API_ENTRY_CHECK(msg)                                                   \
   do {                                                                         \
     if (v8::Locker::IsActive()) {                                              \
       ApiCheck(i::ThreadManager::IsLockedByCurrentThread(),                    \
                msg,                                                            \
@@ skipping 207 matching lines @@
   i::FlagList::SetFlagsFromCommandLine(argc, argv, remove_flags);
 }
 
 
 v8::Handle<Value> ThrowException(v8::Handle<v8::Value> value) {
   if (IsDeadCheck("v8::ThrowException()")) return v8::Handle<Value>();
   ENTER_V8;
   // If we're passed an empty handle, we throw an undefined exception
   // to deal more gracefully with out of memory situations.
   if (value.IsEmpty()) {
-    i::Top::ScheduleThrow(HEAP->undefined_value());
+    i::Isolate::Current()->ScheduleThrow(HEAP->undefined_value());
   } else {
-    i::Top::ScheduleThrow(*Utils::OpenHandle(*value));
+    i::Isolate::Current()->ScheduleThrow(*Utils::OpenHandle(*value));
   }
   return v8::Undefined();
 }
 
 
 RegisteredExtension* RegisteredExtension::first_extension_ = NULL;
 
 
 RegisteredExtension::RegisteredExtension(Extension* extension)
     : extension_(extension), state_(UNVISITED) { }
@@ skipping 140 matching lines @@
 
 
 void Context::Enter() {
   if (IsDeadCheck("v8::Context::Enter()")) return;
   ENTER_V8;
   i::Handle<i::Context> env = Utils::OpenHandle(this);
   // TODO(isolates): Context should have a pointer to isolate.
   i::Isolate* isolate = i::Isolate::Current();
   isolate->handle_scope_implementer()->EnterContext(env);
 
-  isolate->handle_scope_implementer()->SaveContext(i::Top::context());
-  i::Top::set_context(*env);
+  isolate->handle_scope_implementer()->SaveContext(isolate->context());
+  isolate->set_context(*env);
 }
 
 
 void Context::Exit() {
   if (!i::V8::IsRunning()) return;
   // TODO(isolates): Context should have a pointer to isolate.
   i::Isolate* isolate = i::Isolate::Current();
 
   if (!ApiCheck(isolate->handle_scope_implementer()->LeaveLastContext(),
                 "v8::Context::Exit()",
                 "Cannot exit non-entered context")) {
     return;
   }
 
   // Content of 'last_context' could be NULL.
   i::Context* last_context =
       isolate->handle_scope_implementer()->RestoreContext();
-  i::Top::set_context(last_context);
+  isolate->set_context(last_context);
 }
 
 
 void Context::SetData(v8::Handle<String> data) {
   if (IsDeadCheck("v8::Context::SetData()")) return;
   ENTER_V8;
   {
     HandleScope scope;
     i::Handle<i::Context> env = Utils::OpenHandle(this);
     i::Handle<i::Object> raw_data = Utils::OpenHandle(*data);
@@ skipping 699 matching lines @@
   ON_BAILOUT("v8::Script::Compile()", return Local<Script>());
   LOG_API("Script::Compile");
   ENTER_V8;
   Local<Script> generic = New(source, origin, pre_data, script_data);
   if (generic.IsEmpty())
     return generic;
   i::Handle<i::Object> obj = Utils::OpenHandle(*generic);
   i::Handle<i::SharedFunctionInfo> function =
       i::Handle<i::SharedFunctionInfo>(i::SharedFunctionInfo::cast(*obj));
   i::Handle<i::JSFunction> result =
-      i::Factory::NewFunctionFromSharedFunctionInfo(function,
-                                                    i::Top::global_context());
+      i::Factory::NewFunctionFromSharedFunctionInfo(
+          function,
+          i::Isolate::Current()->global_context());
   return Local<Script>(ToApi<Script>(result));
 }
 
 
 Local<Script> Script::Compile(v8::Handle<String> source,
                               v8::Handle<Value> file_name,
                               v8::Handle<String> script_data) {
   ScriptOrigin origin(file_name);
   return Compile(source, &origin, 0, script_data);
 }
 
 
 Local<Value> Script::Run() {
   ON_BAILOUT("v8::Script::Run()", return Local<Value>());
   LOG_API("Script::Run");
   ENTER_V8;
   i::Object* raw_result = NULL;
   {
     HandleScope scope;
     i::Handle<i::Object> obj = Utils::OpenHandle(this);
     i::Handle<i::JSFunction> fun;
     if (obj->IsSharedFunctionInfo()) {
       i::Handle<i::SharedFunctionInfo>
           function_info(i::SharedFunctionInfo::cast(*obj));
       fun = i::Factory::NewFunctionFromSharedFunctionInfo(
-          function_info, i::Top::global_context());
+          function_info, i::Isolate::Current()->global_context());
     } else {
       fun = i::Handle<i::JSFunction>(i::JSFunction::cast(*obj));
     }
     EXCEPTION_PREAMBLE();
-    i::Handle<i::Object> receiver(i::Top::context()->global_proxy());
+    i::Handle<i::Object> receiver(
+        i::Isolate::Current()->context()->global_proxy());
     i::Handle<i::Object> result =
         i::Execution::Call(fun, receiver, 0, NULL, &has_pending_exception);
     EXCEPTION_BAILOUT_CHECK(Local<Value>());
     raw_result = *result;
   }
   i::Handle<i::Object> result(raw_result);
   return Utils::ToLocal(result);
 }
 
 
@@ skipping 37 matching lines @@
     i::Handle<i::Script> script(i::Script::cast(function_info->script()));
     script->set_data(*raw_data);
   }
 }
 
 
 // --- E x c e p t i o n s ---
 
 
 v8::TryCatch::TryCatch()
-    : next_(i::Top::try_catch_handler_address()),
+    : next_(i::Isolate::Current()->try_catch_handler_address()),
       exception_(HEAP->the_hole_value()),
       message_(i::Smi::FromInt(0)),
       is_verbose_(false),
       can_continue_(true),
       capture_message_(true),
       rethrow_(false) {
-  i::Top::RegisterTryCatchHandler(this);
+  i::Isolate::Current()->RegisterTryCatchHandler(this);
 }
 
 
 v8::TryCatch::~TryCatch() {
   if (rethrow_) {
     v8::HandleScope scope;
     v8::Local<v8::Value> exc = v8::Local<v8::Value>::New(Exception());
-    i::Top::UnregisterTryCatchHandler(this);
+    i::Isolate::Current()->UnregisterTryCatchHandler(this);
     v8::ThrowException(exc);
   } else {
-    i::Top::UnregisterTryCatchHandler(this);
+    i::Isolate::Current()->UnregisterTryCatchHandler(this);
   }
 }
 
 
 bool v8::TryCatch::HasCaught() const {
   return !reinterpret_cast<i::Object*>(exception_)->IsTheHole();
 }
 
 
 bool v8::TryCatch::CanContinue() const {
@@ skipping 106 matching lines @@
   return scope.Close(Utils::ToLocal(data));
 }
 
 
 static i::Handle<i::Object> CallV8HeapFunction(const char* name,
                                                i::Handle<i::Object> recv,
                                                int argc,
                                                i::Object** argv[],
                                                bool* has_pending_exception) {
   i::Handle<i::String> fmt_str = i::Factory::LookupAsciiSymbol(name);
-  i::Object* object_fun = i::Top::builtins()->GetProperty(*fmt_str);
+  i::Object* object_fun =
+      i::Isolate::Current()->builtins()->GetProperty(*fmt_str);
   i::Handle<i::JSFunction> fun =
       i::Handle<i::JSFunction>(i::JSFunction::cast(object_fun));
   i::Handle<i::Object> value =
       i::Execution::Call(fun, recv, argc, argv, has_pending_exception);
   return value;
 }
 
 
 static i::Handle<i::Object> CallV8HeapFunction(const char* name,
                                                i::Handle<i::Object> data,
                                                bool* has_pending_exception) {
   i::Object** argv[1] = { data.location() };
   return CallV8HeapFunction(name,
-                            i::Top::builtins(),
+                            i::Isolate::Current()->builtins(),
                             1,
                             argv,
                             has_pending_exception);
 }
 
 
 int Message::GetLineNumber() const {
   ON_BAILOUT("v8::Message::GetLineNumber()", return kNoLineNumberInfo);
   ENTER_V8;
   HandleScope scope;
@@ skipping 70 matching lines @@
     return scope.Close(Utils::ToLocal(i::Handle<i::String>::cast(result)));
   } else {
     return Local<String>();
   }
 }
 
 
 void Message::PrintCurrentStackTrace(FILE* out) {
   if (IsDeadCheck("v8::Message::PrintCurrentStackTrace()")) return;
   ENTER_V8;
-  i::Top::PrintCurrentStackTrace(out);
+  i::Isolate::Current()->PrintCurrentStackTrace(out);
 }
 
 
 // --- S t a c k T r a c e ---
 
 Local<StackFrame> StackTrace::GetFrame(uint32_t index) const {
   if (IsDeadCheck("v8::StackTrace::GetFrame()")) return Local<StackFrame>();
   ENTER_V8;
   HandleScope scope;
   i::Handle<i::JSArray> self = Utils::OpenHandle(this);
@@ skipping 13 matching lines @@
   if (IsDeadCheck("v8::StackTrace::AsArray()")) Local<Array>();
   ENTER_V8;
   return Utils::ToLocal(Utils::OpenHandle(this));
 }
 
 
 Local<StackTrace> StackTrace::CurrentStackTrace(int frame_limit,
     StackTraceOptions options) {
   if (IsDeadCheck("v8::StackTrace::CurrentStackTrace()")) Local<StackTrace>();
   ENTER_V8;
-  return i::Top::CaptureCurrentStackTrace(frame_limit, options);
+  return i::Isolate::Current()->CaptureCurrentStackTrace(frame_limit, options);
 }
 
 
 // --- S t a c k F r a m e ---
 
 int StackFrame::GetLineNumber() const {
   if (IsDeadCheck("v8::StackFrame::GetLineNumber()")) {
     return Message::kNoLineNumberInfo;
   }
   ENTER_V8;
@@ skipping 1696 matching lines @@
 }
 
 
 bool Context::HasOutOfMemoryException() {
   i::Handle<i::Context> env = Utils::OpenHandle(this);
   return env->has_out_of_memory();
 }
 
 
 bool Context::InContext() {
-  return i::Top::context() != NULL;
+  return i::Isolate::Current()->context() != NULL;
 }
 
 
 v8::Local<v8::Context> Context::GetEntered() {
   if (IsDeadCheck("v8::Context::GetEntered()")) return Local<Context>();
   i::Handle<i::Object> last =
       i::Isolate::Current()->handle_scope_implementer()->LastEnteredContext();
   if (last.is_null()) return Local<Context>();
   i::Handle<i::Context> context = i::Handle<i::Context>::cast(last);
   return Utils::ToLocal(context);
 }
 
 
 v8::Local<v8::Context> Context::GetCurrent() {
   if (IsDeadCheck("v8::Context::GetCurrent()")) return Local<Context>();
-  i::Handle<i::Object> current = i::Top::global_context();
+  i::Handle<i::Object> current = i::Isolate::Current()->global_context();
   if (current.is_null()) return Local<Context>();
   i::Handle<i::Context> context = i::Handle<i::Context>::cast(current);
   return Utils::ToLocal(context);
 }
 
 
 v8::Local<v8::Context> Context::GetCalling() {
   if (IsDeadCheck("v8::Context::GetCalling()")) return Local<Context>();
-  i::Handle<i::Object> calling = i::Top::GetCallingGlobalContext();
+  i::Handle<i::Object> calling =
+      i::Isolate::Current()->GetCallingGlobalContext();
   if (calling.is_null()) return Local<Context>();
   i::Handle<i::Context> context = i::Handle<i::Context>::cast(calling);
   return Utils::ToLocal(context);
 }
 
 
 v8::Local<v8::Object> Context::Global() {
   if (IsDeadCheck("v8::Context::Global()")) return Local<v8::Object>();
   i::Object** ctx = reinterpret_cast<i::Object**>(this);
   i::Handle<i::Context> context =
@@ skipping 278 matching lines @@
   i::StringShape shape(*obj);
   return !shape.IsExternal();
 }
 
 
 Local<v8::Object> v8::Object::New() {
   EnsureInitialized("v8::Object::New()");
   LOG_API("Object::New");
   ENTER_V8;
   i::Handle<i::JSObject> obj =
-      i::Factory::NewJSObject(i::Top::object_function());
+      i::Factory::NewJSObject(i::Isolate::Current()->object_function());
   return Utils::ToLocal(obj);
 }
 
 
 Local<v8::Value> v8::Date::New(double time) {
   EnsureInitialized("v8::Date::New()");
   LOG_API("Date::New");
   if (isnan(time)) {
     // Introduce only canonical NaN value into the VM, to avoid signaling NaNs.
     time = i::OS::nan_value();
@@ skipping 160 matching lines @@
 
 void V8::EnableSlidingStateWindow() {
   if (IsDeadCheck("v8::V8::EnableSlidingStateWindow()")) return;
   i::Logger::EnableSlidingStateWindow();
 }
 
 
 void V8::SetFailedAccessCheckCallbackFunction(
       FailedAccessCheckCallback callback) {
   if (IsDeadCheck("v8::V8::SetFailedAccessCheckCallbackFunction()")) return;
-  i::Top::SetFailedAccessCheckCallback(callback);
+  i::Isolate::Current()->SetFailedAccessCheckCallback(callback);
 }
 
 
 void V8::AddObjectGroup(Persistent<Value>* objects, size_t length) {
   if (IsDeadCheck("v8::V8::AddObjectGroup()")) return;
   STATIC_ASSERT(sizeof(Persistent<Value>) == sizeof(i::Object**));
   i::GlobalHandles::AddGroup(reinterpret_cast<i::Object***>(objects), length);
 }
 
 
@@ skipping 105 matching lines @@
   ASSERT(max_size >= kMinimumSizeForLogLinesBuffer);
   return i::Logger::GetLogLines(from_pos, dest_buf, max_size);
 #endif
   return 0;
 }
 
 
 int V8::GetCurrentThreadId() {
   API_ENTRY_CHECK("V8::GetCurrentThreadId()");
   EnsureInitialized("V8::GetCurrentThreadId()");
-  return i::Top::thread_id();
+  return i::Isolate::Current()->thread_id();
 }
 
 
 void V8::TerminateExecution(int thread_id) {
   if (!i::V8::IsRunning()) return;
   API_ENTRY_CHECK("V8::GetCurrentThreadId()");
   i::Isolate* isolate = i::Isolate::Current();
   // If the thread_id identifies the current thread just terminate
   // execution right away.  Otherwise, ask the thread manager to
   // terminate the thread with the given id if any.
-  if (thread_id == i::Top::thread_id()) {
+  if (thread_id == isolate->thread_id()) {
     isolate->stack_guard()->TerminateExecution();
   } else {
     i::ThreadManager::TerminateExecution(thread_id);
   }
 }
 
 
 void V8::TerminateExecution() {
   if (!i::V8::IsRunning()) return;
   i::Isolate::Current()->stack_guard()->TerminateExecution();
 }
 
 
 bool V8::IsExecutionTerminating() {
   if (!i::V8::IsRunning()) return false;
-  if (i::Top::has_scheduled_exception()) {
-    return i::Top::scheduled_exception() == HEAP->termination_exception();
+  if (i::Isolate::Current()->has_scheduled_exception()) {
+    return i::Isolate::Current()->scheduled_exception() ==
+        HEAP->termination_exception();
   }
   return false;
 }
 
 
 String::Utf8Value::Utf8Value(v8::Handle<v8::Value> obj) {
   EnsureInitialized("v8::String::Utf8Value::Utf8Value()");
   if (obj.IsEmpty()) {
     str_ = NULL;
     length_ = 0;
@@ skipping 728 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal