Add the CHECK_ISOLATE macro, which validates that the current isolate

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 10 matching lines @@
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 #include "vm/snapshot.h"
 #include "vm/stack_frame.h"
 #include "vm/timer.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
-static const char* CanonicalFunction(const char* func) {
+const char* CanonicalFunction(const char* func) {
   if (strncmp(func, "dart::", 6) == 0) {
     return func + 6;
   } else {
     return func;
   }
 }
 
-#define CURRENT_FUNC CanonicalFunction(__FUNCTION__)
-
 #define RETURN_TYPE_ERROR(dart_handle, Type)                                  \
   do {                                                                        \
     const Object& tmp = Object::Handle(Api::UnwrapHandle((dart_handle)));     \
     if (tmp.IsNull()) {                                                       \
       return Api::Error("%s expects argument '%s' to be non-null.",           \
                         CURRENT_FUNC, #dart_handle);                          \
     } else if (tmp.IsApiError()) {                                            \
       return dart_handle;                                                     \
     } else {                                                                  \
       return Api::Error("%s expects argument '%s' to be of type %s.",         \
@@ skipping 160 matching lines @@
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* true_handle = state->True();
   return reinterpret_cast<Dart_Handle>(true_handle);
 }
 
 
 Dart_Handle Api::Error(const char* format, ...) {
-  DARTSCOPE(Isolate::Current());
+  DARTSCOPE_NOCHECKS(Isolate::Current());
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = reinterpret_cast<char*>(zone.Allocate(len + 1));
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   const String& message = String::Handle(String::New(buffer));
   const Object& obj = Object::Handle(ApiError::New(message));
   return Api::NewLocalHandle(obj);
 }
 
 
 Dart_Handle Api::ErrorFromException(const Object& obj) {
-  DARTSCOPE(Isolate::Current());
+  DARTSCOPE_NOCHECKS(Isolate::Current());
 
   ASSERT(obj.IsUnhandledException());
   if (obj.IsUnhandledException()) {
     UnhandledException& uhe = UnhandledException::Handle();
     uhe ^= obj.raw();
     const Object& error = Object::Handle(ApiError::New(uhe));
     return Api::NewLocalHandle(error);
   } else {
     return Api::Error("Internal error: expected obj.IsUnhandledException().");
   }
@@ skipping 232 matching lines @@
   DARTSCOPE(Isolate::Current());
   const Object& expected = Object::Handle(Api::UnwrapHandle(obj1));
   const Object& actual = Object::Handle(Api::UnwrapHandle(obj2));
   *value = (expected.raw() == actual.raw());
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewPersistentHandle(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE(isolate);
+  CHECK_ISOLATE(isolate);
+  DARTSCOPE_NOCHECKS(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Object& old_ref = Object::Handle(Api::UnwrapHandle(object));
   PersistentHandle* new_ref = state->persistent_handles().AllocateHandle();
   new_ref->set_raw(old_ref);
   return reinterpret_cast<Dart_Handle>(new_ref);
 }
 
 
 DART_EXPORT void Dart_DeletePersistentHandle(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
+  CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* ref = Api::UnwrapAsPersistentHandle(*state, object);
   ASSERT(!ref->IsProtected());
   if (!ref->IsProtected()) {
     state->persistent_handles().FreeHandle(ref);
   }
 }
 
 
@@ skipping 29 matching lines @@
 }
 
 
 // --- Isolates ---
 
 
 DART_EXPORT Dart_Isolate Dart_CreateIsolate(const uint8_t* snapshot,
                                             void* callback_data,
                                             char** error) {
   Isolate* isolate = Dart::CreateIsolate();
-  ASSERT(isolate != NULL);
+  assert(isolate != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     Dart::InitializeIsolate(snapshot, callback_data);
     START_TIMER(time_total_runtime);
     isolate->set_long_jump_base(base);
     return reinterpret_cast<Dart_Isolate>(isolate);
   } else {
     {
-      DARTSCOPE(isolate);
+      DARTSCOPE_NOCHECKS(isolate);
       const String& errmsg =
           String::Handle(isolate->object_store()->sticky_error());
       *error = strdup(errmsg.ToCString());
     }
     Dart::ShutdownIsolate();
   }
   return reinterpret_cast<Dart_Isolate>(NULL);
 }
 
 
 DART_EXPORT void Dart_ShutdownIsolate() {
-  ASSERT(Isolate::Current() != NULL);
+  CHECK_ISOLATE(Isolate::Current());
   STOP_TIMER(time_total_runtime);
   Dart::ShutdownIsolate();
 }
 
 
 DART_EXPORT Dart_Isolate Dart_CurrentIsolate() {
   return Api::CastIsolate(Isolate::Current());
 }
 
 
 DART_EXPORT void Dart_EnterIsolate(Dart_Isolate dart_isolate) {
+  CHECK_NO_ISOLATE(Isolate::Current());
   Isolate* isolate = reinterpret_cast<Isolate*>(dart_isolate);
-  ASSERT(Isolate::Current() == NULL);
   Isolate::SetCurrent(isolate);
 }
 
 
 DART_EXPORT void Dart_ExitIsolate() {
-  ASSERT(Isolate::Current() != NULL);
+  CHECK_ISOLATE(Isolate::Current());
   Isolate::SetCurrent(NULL);
 }
 
 
 static uint8_t* ApiAllocator(uint8_t* ptr,
                              intptr_t old_size,
                              intptr_t new_size) {
   uword new_ptr = Api::Reallocate(reinterpret_cast<uword>(ptr),
                                   old_size,
                                   new_size);
@@ skipping 22 matching lines @@
 }
 
 
 // --- Messages and Ports ---
 
 
 DART_EXPORT void Dart_SetMessageCallbacks(
     Dart_PostMessageCallback post_message_callback,
     Dart_ClosePortCallback close_port_callback) {
   Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
+  CHECK_ISOLATE(isolate);
   ASSERT(post_message_callback != NULL);
   ASSERT(close_port_callback != NULL);
   isolate->set_post_message_callback(post_message_callback);
   isolate->set_close_port_callback(close_port_callback);
 }
 
 
 static RawInstance* DeserializeMessage(void* data) {
   // Create a snapshot object using the buffer.
   const Snapshot* snapshot = Snapshot::SetupFromBuffer(data);
@@ skipping 81 matching lines @@
   MessageWriter writer(&buffer, &allocator);
 
   writer.WriteMessage(len, data);
 
   // Post the message at the given port.
   return PortMap::PostMessage(port_id, kNoReplyPort, Api::CastMessage(buffer));
 }
 
 
 DART_EXPORT bool Dart_Post(Dart_Port port_id, Dart_Handle handle) {
-  DARTSCOPE(Isolate::Current());
+  Isolate* isolate = Isolate::Current();
+  CHECK_ISOLATE(isolate);
+  DARTSCOPE_NOCHECKS(isolate);
   const Object& object = Object::Handle(Api::UnwrapHandle(handle));
   uint8_t* data = NULL;
   SnapshotWriter writer(false, &data, &allocator);
   writer.WriteObject(object.raw());
   writer.FinalizeBuffer();
   return PortMap::PostMessage(port_id, kNoReplyPort, Api::CastMessage(data));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewSendPort(Dart_Port port_id) {
@@ skipping 39 matching lines @@
   GrowableArray<const Object*> arguments(kNumArguments);
   arguments.Add(&Integer::Handle(Integer::New(port_id)));
   Dart_Handle result;
   InvokeStatic(isolate, function, arguments, &result);
   return result;
 }
 
 
 DART_EXPORT Dart_Port Dart_GetMainPortId() {
   Isolate* isolate = Isolate::Current();
-  ASSERT(isolate);
+  CHECK_ISOLATE(isolate);
   return isolate->main_port();
 }
 
 // --- Scopes ----
 
 
 DART_EXPORT void Dart_EnterScope() {
   Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
+  CHECK_ISOLATE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* new_scope = new ApiLocalScope(state->top_scope(),
                                                reinterpret_cast<uword>(&state));
   ASSERT(new_scope != NULL);
   state->set_top_scope(new_scope);  // New scope is now the top scope.
 }
 
 
 DART_EXPORT void Dart_ExitScope() {
   Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
+  CHECK_ISOLATE_SCOPE(isolate);
   ApiState* state = isolate->api_state();
-  ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
-  ASSERT(scope != NULL);
+
   state->set_top_scope(scope->previous());  // Reset top scope to previous.
   delete scope;  // Free up the old scope which we have just exited.
 }
 
 
 // --- Objects ----
 
 
 DART_EXPORT Dart_Handle Dart_Null() {
+  CHECK_ISOLATE_SCOPE(Isolate::Current());
   return Api::Null();
 }
 
 
 DART_EXPORT bool Dart_IsNull(Dart_Handle object) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsNull();
 }
 
@@ skipping 141 matching lines @@
     return Api::Success();
   }
   return Api::Error("Object is not a Integer");
 }
 
 
 // --- Booleans ----
 
 
 DART_EXPORT Dart_Handle Dart_True() {
+  CHECK_ISOLATE_SCOPE(Isolate::Current());
   return Api::True();
 }
 
 
 DART_EXPORT Dart_Handle Dart_False() {
+  CHECK_ISOLATE_SCOPE(Isolate::Current());
   return Api::False();
 }
 
 
 DART_EXPORT bool Dart_IsBoolean(Dart_Handle object) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsBool();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewBoolean(bool value) {
+  CHECK_ISOLATE_SCOPE(Isolate::Current());
   return value ? Api::True() : Api::False();
 }
 
 
 DART_EXPORT Dart_Handle Dart_BooleanValue(Dart_Handle bool_object,
                                           bool* value) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(bool_object));
   if (obj.IsBool()) {
     Bool& bool_obj = Bool::Handle();
@@ skipping 1023 matching lines @@
   ASSERT(state != NULL);
   state->UnwindScopes(isolate->top_exit_frame_info());
   Exceptions::Throw(excp);
   return Api::Error("Exception was not thrown, internal error");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ReThrowException(Dart_Handle exception,
                                               Dart_Handle stacktrace) {
   Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
+  CHECK_ISOLATE(isolate);
   if (isolate->top_exit_frame_info() == 0) {
     // There are no dart frames on the stack so it would be illegal to
     // throw an exception here.
     return Api::Error("No Dart frames on stack, cannot throw exception");
   }
   DARTSCOPE(isolate);
   const Instance& excp = Instance::CheckedHandle(Api::UnwrapHandle(exception));
   const Instance& stk = Instance::CheckedHandle(Api::UnwrapHandle(stacktrace));
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
@@ skipping 11 matching lines @@
 DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args,
                                                int index) {
   DARTSCOPE(Isolate::Current());
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   const Object& obj = Object::Handle(arguments->At(index));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT int Dart_GetNativeArgumentCount(Dart_NativeArguments args) {
+  CHECK_ISOLATE(Isolate::Current());
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   return arguments->Count();
 }
 
 
 DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args,
                                      Dart_Handle retval) {
   DARTSCOPE(Isolate::Current());
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   arguments->SetReturn(Object::Handle(Api::UnwrapHandle(retval)));
@@ skipping 271 matching lines @@
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 
 }  // namespace dart