Add Dart_PropagateError.

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"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/dart_entry.h"
 #include "vm/debuginfo.h"
 #include "vm/exceptions.h"
 #include "vm/growable_array.h"
-#include "vm/longjump.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #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"
 
@@ skipping 50 matching lines @@
 }
 
 
 void SetupErrorResult(Dart_Handle* handle) {
   const Error& error = Error::Handle(
       Isolate::Current()->object_store()->sticky_error());
   *handle = Api::NewLocalHandle(error);
 }
 
 
-// NOTE: Need to pass 'result' as a parameter here in order to avoid
-// warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
-// which shows up because of the use of setjmp.
-static void InvokeStatic(Isolate* isolate,
-                         const Function& function,
-                         GrowableArray<const Object*>& args,
-                         Dart_Handle* result) {
-  ASSERT(isolate != NULL);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    const Array& kNoArgumentNames = Array::Handle();
-    const Instance& retval = Instance::Handle(
-        DartEntry::InvokeStatic(function, args, kNoArgumentNames));
-    *result = Api::NewLocalHandle(retval);
-  } else {
-    SetupErrorResult(result);
-  }
-  isolate->set_long_jump_base(base);
-}
-
-
-// NOTE: Need to pass 'result' as a parameter here in order to avoid
-// warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
-// which shows up because of the use of setjmp.
-static void InvokeDynamic(Isolate* isolate,
-                          const Instance& receiver,
-                          const Function& function,
-                          GrowableArray<const Object*>& args,
-                          Dart_Handle* result) {
-  ASSERT(isolate != NULL);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    const Array& kNoArgumentNames = Array::Handle();
-    const Instance& retval = Instance::Handle(
-        DartEntry::InvokeDynamic(receiver, function, args, kNoArgumentNames));
-    *result = Api::NewLocalHandle(retval);
-  } else {
-    SetupErrorResult(result);
-  }
-  isolate->set_long_jump_base(base);
-}
-
-
 Dart_Handle Api::NewLocalHandle(const Object& object) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   LocalHandles* local_handles = scope->local_handles();
   ASSERT(local_handles != NULL);
   LocalHandle* ref = local_handles->AllocateHandle();
@@ skipping 224 matching lines @@
   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_EXPORT Dart_Handle Dart_PropagateError(Dart_Handle handle) {
+  Isolate* isolate = Isolate::Current();
+  CHECK_ISOLATE(isolate);
+  const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
+  if (!obj.IsError()) {
+    return Api::NewError(
+        "%s expects argument 'handle' to be an error handle.  "
+        "Did you forget to check Dart_IsError first?",
+        CURRENT_FUNC);
+  }
+  if (isolate->top_exit_frame_info() == 0) {
+    // There are no dart frames on the stack so it would be illegal to
+    // propagate an error here.
+    return Api::NewError("No Dart frames on stack, cannot propagate error.");
+  }
+
+  // Unwind all the API scopes till the exit frame before propagating.
+  ApiState* state = isolate->api_state();
+  ASSERT(state != NULL);
+  state->UnwindScopes(isolate->top_exit_frame_info());
+
+  Error& error = Error::Handle();
+  error ^= obj.raw();
+  Exceptions::PropagateError(error);
+  UNREACHABLE();
+
+  return Api::NewError("Cannot reach here.  Internal error.");
+}
+
+
 DART_EXPORT void _Dart_ReportErrorHandle(const char* file,
                                            int line,
                                            const char* handle,
                                            const char* message) {
   fprintf(stderr, "%s:%d: error handle: '%s':\n    '%s'\n",
           file, line, handle, message);
   OS::Abort();
 }
 
 
@@ skipping 107 matching lines @@
 
 // --- Isolates ---
 
 
 DART_EXPORT Dart_Isolate Dart_CreateIsolate(const char* name_prefix,
                                             const uint8_t* snapshot,
                                             void* callback_data,
                                             char** error) {
   Isolate* isolate = Dart::CreateIsolate(name_prefix);
   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);
+  DARTSCOPE_NOCHECKS(isolate);
+  const Error& error_obj =
+      Error::Handle(Dart::InitializeIsolate(snapshot, callback_data));
+  if (error_obj.IsNull()) {
     START_TIMER(time_total_runtime);
-    isolate->set_long_jump_base(base);
     return reinterpret_cast<Dart_Isolate>(isolate);
   } else {
-    {
-      DARTSCOPE_NOCHECKS(isolate);
-      const Error& error_obj =
-          Error::Handle(isolate->object_store()->sticky_error());
-      *error = strdup(error_obj.ToErrorCString());
-    }
+    *error = strdup(error_obj.ToErrorCString());
     Dart::ShutdownIsolate();
+    return reinterpret_cast<Dart_Isolate>(NULL);
   }
-  return reinterpret_cast<Dart_Isolate>(NULL);
 }
 
 
 DART_EXPORT void Dart_ShutdownIsolate() {
   CHECK_ISOLATE(Isolate::Current());
   STOP_TIMER(time_total_runtime);
   Dart::ShutdownIsolate();
 }
 
 
@@ skipping 102 matching lines @@
   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);
 }
 
 
 DART_EXPORT Dart_Handle Dart_RunLoop() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
-
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  Dart_Handle result;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    const Object& obj = Object::Handle(isolate->StandardRunLoop());
-    if (obj.IsError()) {
-      result = Api::NewLocalHandle(obj);
-    } else {
-      ASSERT(obj.IsNull());
-      result = Api::Success();
-    }
-  } else {
-    SetupErrorResult(&result);
+  const Object& obj = Object::Handle(isolate->StandardRunLoop());
+  if (obj.IsError()) {
+    return Api::NewLocalHandle(obj);
   }
-  isolate->set_long_jump_base(base);
-  return result;
+  ASSERT(obj.IsNull());
+  return Api::Success();
 }
 
 
 static RawInstance* DeserializeMessage(void* data) {
   // Create a snapshot object using the buffer.
   const Snapshot* snapshot = Snapshot::SetupFromBuffer(data);
   ASSERT(snapshot->IsMessageSnapshot());
 
   // Read object back from the snapshot.
   SnapshotReader reader(snapshot, Isolate::Current());
   Instance& instance = Instance::Handle();
   instance ^= reader.ReadObject();
   return instance.raw();
 }
 
 
 DART_EXPORT Dart_Handle Dart_HandleMessage(Dart_Port dest_port_id,
                                            Dart_Port reply_port_id,
                                            Dart_Message dart_message) {
   DARTSCOPE(Isolate::Current());
   const Instance& msg = Instance::Handle(DeserializeMessage(dart_message));
-  // TODO(turnidge): Should this call be wrapped in a longjmp?
   const Object& result =
       Object::Handle(DartLibraryCalls::HandleMessage(dest_port_id,
                                                      reply_port_id,
                                                      msg));
   if (result.IsError()) {
     return Api::NewLocalHandle(result);
   }
   ASSERT(result.IsNull());
   return Api::Success();
 }
@@ skipping 49 matching lines @@
   // function resolution by class name and function name more concise.
   const Function& function = Function::Handle(
       Resolver::ResolveStatic(Library::Handle(Library::CoreLibrary()),
                               class_name,
                               function_name,
                               kNumArguments,
                               kNoArgumentNames,
                               Resolver::kIsQualified));
   GrowableArray<const Object*> arguments(kNumArguments);
   arguments.Add(&Integer::Handle(Integer::New(port_id)));
-  Dart_Handle result;
-  InvokeStatic(isolate, function, arguments, &result);
-  return result;
+  const Object& result = Object::Handle(
+      DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
+  return Api::NewLocalHandle(result);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetReceivePort(Dart_Port port_id) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& class_name =
       String::Handle(String::NewSymbol("ReceivePortImpl"));
   const String& function_name =
       String::Handle(String::NewSymbol("_get_or_create"));
   const int kNumArguments = 1;
   const Array& kNoArgumentNames = Array::Handle();
   const Function& function = Function::Handle(
       Resolver::ResolveStatic(Library::Handle(Library::CoreLibrary()),
                               class_name,
                               function_name,
                               kNumArguments,
                               kNoArgumentNames,
                               Resolver::kIsQualified));
   GrowableArray<const Object*> arguments(kNumArguments);
   arguments.Add(&Integer::Handle(Integer::New(port_id)));
-  Dart_Handle result;
-  InvokeStatic(isolate, function, arguments, &result);
-  return result;
+  const Object& result = Object::Handle(
+      DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
+  return Api::NewLocalHandle(result);
 }
 
 
 DART_EXPORT Dart_Port Dart_GetMainPortId() {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   return isolate->main_port();
 }
 
 // --- Scopes ----
@@ skipping 36 matching lines @@
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsNull();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, Dart_Handle obj2,
                                           bool* value) {
   DARTSCOPE(Isolate::Current());
   const Instance& expected = Instance::CheckedHandle(Api::UnwrapHandle(obj1));
   const Instance& actual = Instance::CheckedHandle(Api::UnwrapHandle(obj2));
-  const Instance& result =
-      Instance::Handle(DartLibraryCalls::Equals(expected, actual));
+  const Object& result =
+      Object::Handle(DartLibraryCalls::Equals(expected, actual));
   if (result.IsBool()) {
     Bool& b = Bool::Handle();
     b ^= result.raw();
     *value = b.value();
     return Api::Success();
   } else if (result.IsError()) {
     return Api::NewLocalHandle(result);
   } else {
     return Api::NewError("Expected boolean result from ==");
   }
@@ skipping 502 matching lines @@
   const Object& obj = Object::Handle(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     *len = array_obj.Length();
     return Api::Success();
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
-  if (!instance.IsNull()) {
-    String& name = String::Handle(String::New("length"));
-    name = Field::GetterName(name);
-    const Function& function = Function::Handle(
-        Resolver::ResolveDynamic(instance, name, 1, 0));
-    if (!function.IsNull()) {
-      GrowableArray<const Object*> args(0);
-      LongJump* base = isolate->long_jump_base();
-      LongJump jump;
-      isolate->set_long_jump_base(&jump);
-      Dart_Handle result;
-      if (setjmp(*jump.Set()) == 0) {
-        const Array& kNoArgumentNames = Array::Handle();
-        const Instance& retval = Instance::Handle(
-            DartEntry::InvokeDynamic(instance,
-                                     function,
-                                     args,
-                                     kNoArgumentNames));
-        result = Api::Success();
-        if (retval.IsSmi() || retval.IsMint()) {
-          Integer& integer = Integer::Handle();
-          integer ^= retval.raw();
-          *len = integer.AsInt64Value();
-        } else if (retval.IsBigint()) {
-          Bigint& bigint = Bigint::Handle();
-          bigint ^= retval.raw();
-          if (BigintOperations::FitsIntoInt64(bigint)) {
-            *len = BigintOperations::ToInt64(bigint);
-          } else {
-            result =
-                Api::NewError("Length of List object is greater than the "
-                              "maximum value that 'len' parameter can hold");
-          }
-        } else if (retval.IsError()) {
-          result = Api::NewLocalHandle(retval);
-        } else {
-          result = Api::NewError("Length of List object is not an integer");
-        }
-      } else {
-        SetupErrorResult(&result);
-      }
-      isolate->set_long_jump_base(base);
-      return result;
+  if (instance.IsNull()) {
+    return Api::NewError("Object does not implement the List inteface");
+  }
+  String& name = String::Handle(String::New("length"));
+  name = Field::GetterName(name);
+  const Function& function = Function::Handle(
+      Resolver::ResolveDynamic(instance, name, 1, 0));
+  if (function.IsNull()) {
+    return Api::NewError("List object does not have a 'length' field.");
+  }
+
+  GrowableArray<const Object*> args(0);
+  Dart_Handle result;
+  const Array& kNoArgumentNames = Array::Handle();
+  const Object& retval = Object::Handle(
+      DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
+  if (retval.IsSmi() || retval.IsMint()) {
+    Integer& integer = Integer::Handle();
+    integer ^= retval.raw();
+    *len = integer.AsInt64Value();
+    return Api::Success();
+  } else if (retval.IsBigint()) {
+    Bigint& bigint = Bigint::Handle();
+    bigint ^= retval.raw();
+    if (BigintOperations::FitsIntoInt64(bigint)) {
+      *len = BigintOperations::ToInt64(bigint);
+      return Api::Success();
+    } else {
+      return Api::NewError("Length of List object is greater than the "
+                           "maximum value that 'len' parameter can hold");
     }
+  } else if (retval.IsError()) {
+    return Api::NewLocalHandle(retval);
+  } else {
+    return Api::NewError("Length of List object is not an integer");
   }
-  return Api::NewError("Object does not implement the list inteface");
 }
 
 
-static RawObject* GetListAt(Isolate* isolate,
-                            const Instance& instance,
-                            const Integer& index,
-                            const Function& function,
-                            Dart_Handle* result) {
-  ASSERT(isolate != NULL);
-  ASSERT(result != NULL);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    Instance& retval = Instance::Handle();
-    GrowableArray<const Object*> args(0);
-    args.Add(&index);
-    const Array& kNoArgumentNames = Array::Handle();
-    retval = DartEntry::InvokeDynamic(instance,
-                                      function,
-                                      args,
-                                      kNoArgumentNames);
-    if (retval.IsError()) {
-      *result = Api::NewLocalHandle(retval);
-    } else {
-      *result = Api::Success();
-    }
-    isolate->set_long_jump_base(base);
-    return retval.raw();
-  }
-  SetupErrorResult(result);
-  isolate->set_long_jump_base(base);
-  return Object::null();
-}
-
-
 DART_EXPORT Dart_Handle Dart_ListGetAt(Dart_Handle list, intptr_t index) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     if ((index >= 0) && (index < array_obj.Length())) {
       const Object& element = Object::Handle(array_obj.At(index));
       return Api::NewLocalHandle(element);
     }
     return Api::NewError("Invalid index passed in to access array element");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("[]"));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 2, 0));
     if (!function.IsNull()) {
-      Object& element = Object::Handle();
+      GrowableArray<const Object*> args(1);
       Integer& indexobj = Integer::Handle();
-      Dart_Handle result;
       indexobj = Integer::New(index);
-      element = GetListAt(isolate, instance, indexobj, function, &result);
-      if (::Dart_IsError(result)) {
-        return result;  // Error condition.
-      }
-      return Api::NewLocalHandle(element);
+      args.Add(&indexobj);
+      const Array& kNoArgumentNames = Array::Handle();
+      const Object& result = Object::Handle(
+          DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
+      return Api::NewLocalHandle(result);
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
-static void SetListAt(Isolate* isolate,
-                      const Instance& instance,
-                      const Integer& index,
-                      const Object& value,
-                      const Function& function,
-                      Dart_Handle* result) {
-  ASSERT(isolate != NULL);
-  ASSERT(result != NULL);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    GrowableArray<const Object*> args(1);
-    args.Add(&index);
-    args.Add(&value);
-    Instance& retval = Instance::Handle();
-    const Array& kNoArgumentNames = Array::Handle();
-    retval = DartEntry::InvokeDynamic(instance,
-                                      function,
-                                      args,
-                                      kNoArgumentNames);
-    if (retval.IsError()) {
-      *result = Api::NewLocalHandle(retval);
-    } else {
-      *result = Api::Success();
-    }
-  } else {
-    SetupErrorResult(result);
-  }
-  isolate->set_long_jump_base(base);
-}
-
-
 DART_EXPORT Dart_Handle Dart_ListSetAt(Dart_Handle list,
                                        intptr_t index,
                                        Dart_Handle value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     if (obj.IsImmutableArray()) {
       return Api::NewError("Cannot modify immutable array");
     }
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     const Object& value_obj = Object::Handle(Api::UnwrapHandle(value));
     if ((index >= 0) && (index < array_obj.Length())) {
       array_obj.SetAt(index, value_obj);
       return Api::Success();
     }
     return Api::NewError("Invalid index passed in to set array element");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("[]="));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 3, 0));
     if (!function.IsNull()) {
-      Dart_Handle result;
       const Integer& index_obj = Integer::Handle(Integer::New(index));
       const Object& value_obj = Object::Handle(Api::UnwrapHandle(value));
-      SetListAt(isolate, instance, index_obj, value_obj, function, &result);
-      return result;
+      GrowableArray<const Object*> args(2);
+      args.Add(&index_obj);
+      args.Add(&value_obj);
+      const Array& kNoArgumentNames = Array::Handle();
+      const Object& result = Object::Handle(
+          DartEntry::InvokeDynamic(instance, function, args, kNoArgumentNames));
+      return Api::NewLocalHandle(result);
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAsBytes(Dart_Handle list,
                                             intptr_t offset,
                                             uint8_t* native_array,
                                             intptr_t length) {
@@ skipping 23 matching lines @@
     return Api::NewError("Invalid length passed in to access array elements");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("[]"));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 2, 0));
     if (!function.IsNull()) {
-      Object& element = Object::Handle();
+      Object& result = Object::Handle();
       Integer& intobj = Integer::Handle();
-      Dart_Handle result;
       for (int i = 0; i < length; i++) {
         intobj = Integer::New(offset + i);
-        element = GetListAt(isolate, instance, intobj, function, &result);
-        if (::Dart_IsError(result)) {
-          return result;  // Error condition.
+        GrowableArray<const Object*> args(1);
+        args.Add(&intobj);
+        const Array& kNoArgumentNames = Array::Handle();
+        result = DartEntry::InvokeDynamic(
+            instance, function, args, kNoArgumentNames);
+        if (result.IsError()) {
+          return Api::NewLocalHandle(result);
         }
-        if (!element.IsInteger()) {
+        if (!result.IsInteger()) {
           return Api::NewError("%s expects the argument 'list' to be "
-                            "a List of int", CURRENT_FUNC);
+                               "a List of int", CURRENT_FUNC);
         }
-        intobj ^= element.raw();
+        intobj ^= result.raw();
         ASSERT(intobj.AsInt64Value() <= 0xff);
         // TODO(hpayer): value should always be smaller then 0xff. Add error
         // handling.
         native_array[i] = static_cast<uint8_t>(intobj.AsInt64Value() & 0xff);
       }
       return Api::Success();
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
@@ skipping 29 matching lines @@
     String& name = String::Handle(String::New("[]="));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 3, 0));
     if (!function.IsNull()) {
       Integer& indexobj = Integer::Handle();
       Integer& valueobj = Integer::Handle();
       Dart_Handle result;
       for (int i = 0; i < length; i++) {
         indexobj = Integer::New(offset + i);
         valueobj = Integer::New(native_array[i]);
-        SetListAt(isolate, instance, indexobj, valueobj, function, &result);
-        if (::Dart_IsError(result)) {
-          return result;  // Error condition.
+        GrowableArray<const Object*> args(2);
+        args.Add(&indexobj);
+        args.Add(&valueobj);
+        const Array& kNoArgumentNames = Array::Handle();
+        const Object& result = Object::Handle(
+            DartEntry::InvokeDynamic(
+                instance, function, args, kNoArgumentNames));
+        if (result.IsError()) {
+          return Api::NewLocalHandle(result);
         }
       }
       return Api::Success();
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
 // --- Closures ---
 
 
 DART_EXPORT bool Dart_IsClosure(Dart_Handle object) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsClosure();
 }
 
 
-// NOTE: Need to pass 'result' as a parameter here in order to avoid
-// warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
-// which shows up because of the use of setjmp.
-static void InvokeClosure(Isolate* isolate,
-                          const Closure& closure,
-                          GrowableArray<const Object*>& args,
-                          Dart_Handle* result) {
-  ASSERT(isolate != NULL);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    const Array& kNoArgumentNames = Array::Handle();
-    const Instance& retval = Instance::Handle(
-        DartEntry::InvokeClosure(closure, args, kNoArgumentNames));
-    *result = Api::NewLocalHandle(retval);
-  } else {
-    SetupErrorResult(result);
-  }
-  isolate->set_long_jump_base(base);
-}
-
-
 DART_EXPORT Dart_Handle Dart_InvokeClosure(Dart_Handle closure,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(closure));
   if (obj.IsNull()) {
     return Api::NewError("Null object passed in to invoke closure");
   }
   if (!obj.IsClosure()) {
     return Api::NewError("Invalid closure passed to invoke closure");
   }
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Now try to invoke the closure.
   Closure& closure_obj = Closure::Handle();
   closure_obj ^= obj.raw();
-  Dart_Handle retval;
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg = Object::Handle(Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
-  InvokeClosure(isolate, closure_obj, dart_arguments, &retval);
-  return retval;
+  const Array& kNoArgumentNames = Array::Handle();
+  const Object& result = Object::Handle(
+      DartEntry::InvokeClosure(closure_obj, dart_arguments, kNoArgumentNames));
+  return Api::NewLocalHandle(result);
 }
 
 
 DART_EXPORT int64_t Dart_ClosureSmrck(Dart_Handle object) {
   DARTSCOPE(Isolate::Current());
   const Closure& obj = Closure::CheckedHandle(Api::UnwrapHandle(object));
   const Integer& smrck = Integer::Handle(obj.smrck());
   return smrck.IsNull() ? 0 : smrck.AsInt64Value();
 }
 
@@ skipping 57 matching lines @@
                   class_name.ToCString(), function_name.ToCString());
     }
     return Api::NewError(msg);
   }
   Dart_Handle retval;
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg = Object::Handle(Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
-  InvokeStatic(isolate, function, dart_arguments, &retval);
-  return retval;
+  const Array& kNoArgumentNames = Array::Handle();
+  const Object& result = Object::Handle(
+      DartEntry::InvokeStatic(function, dart_arguments, kNoArgumentNames));
+  return Api::NewLocalHandle(result);
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeDynamic(Dart_Handle object,
                                            Dart_Handle function_name,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
@@ skipping 21 matching lines @@
     // TODO(5415268): Invoke noSuchMethod instead of failing.
     OS::PrintErr("Unable to find instance function: %s\n", name.ToCString());
     return Api::NewError("Unable to find instance function");
   }
   Dart_Handle retval;
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg = Object::Handle(Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
-  InvokeDynamic(isolate, receiver, function, dart_arguments, &retval);
-  return retval;
+  const Array& kNoArgumentNames = Array::Handle();
+  const Object& result = Object::Handle(
+      DartEntry::InvokeDynamic(
+          receiver, function, dart_arguments, kNoArgumentNames));
+  return Api::NewLocalHandle(result);
 }
 
 
 static const bool kGetter = true;
 static const bool kSetter = false;
 
 
 static bool UseGetterForStaticField(const Field& fld) {
   if (fld.IsNull()) {
     return true;
@@ skipping 86 matching lines @@
   const Object& obj = Object::Handle(Api::UnwrapHandle(result));
   if (obj.IsField()) {
     Field& fld = Field::Handle();
     fld ^= obj.raw();
     retval = fld.value();
     return Api::NewLocalHandle(retval);
   } else {
     Function& func = Function::Handle();
     func ^= obj.raw();
     GrowableArray<const Object*> args;
-    InvokeStatic(isolate, func, args, &result);
-    return result;
+    const Array& kNoArgumentNames = Array::Handle();
+    const Object& result = Object::Handle(
+        DartEntry::InvokeStatic(func, args, kNoArgumentNames));
+    return Api::NewLocalHandle(result);
   }
 }
 
 
 // TODO(iposva): The value parameter should be documented as being an instance.
 // TODO(turnidge): Is this skipping the setter?
 DART_EXPORT Dart_Handle Dart_SetStaticField(Dart_Handle cls,
                                             Dart_Handle name,
                                             Dart_Handle value) {
   DARTSCOPE(Isolate::Current());
@@ skipping 25 matching lines @@
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   Dart_Handle result = LookupInstanceField(object, name, kGetter);
   if (::Dart_IsError(result)) {
     return result;
   }
   Function& func = Function::Handle();
   func ^= Api::UnwrapHandle(result);
   GrowableArray<const Object*> arguments;
-  InvokeDynamic(isolate, object, func, arguments, &result);
-  return result;
+  const Array& kNoArgumentNames = Array::Handle();
+  const Object& retval = Object::Handle(
+      DartEntry::InvokeDynamic(object, func, arguments, kNoArgumentNames));
+  return Api::NewLocalHandle(retval);
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetInstanceField(Dart_Handle obj,
                                               Dart_Handle name,
                                               Dart_Handle value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
     return Api::NewError("Invalid object passed in to access instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   Dart_Handle result = LookupInstanceField(object, name, kSetter);
   if (::Dart_IsError(result)) {
     return result;
   }
   Function& func = Function::Handle();
   func ^= Api::UnwrapHandle(result);
   GrowableArray<const Object*> arguments(1);
   const Object& arg = Object::Handle(Api::UnwrapHandle(value));
   arguments.Add(&arg);
-  InvokeDynamic(isolate, object, func, arguments, &result);
-  return result;
+  const Array& kNoArgumentNames = Array::Handle();
+  const Object& retval = Object::Handle(
+      DartEntry::InvokeDynamic(object, func, arguments, kNoArgumentNames));
+  return Api::NewLocalHandle(retval);
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateNativeWrapperClass(Dart_Handle library,
                                                       Dart_Handle name,
                                                       int field_count) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(name));
   if (param.IsNull() || !param.IsString() || field_count <= 0) {
@@ skipping 143 matching lines @@
                           const String& source,
                           RawScript::Kind kind,
                           Dart_Handle* result) {
   bool update_lib_status = (kind == RawScript::kScript ||
                             kind == RawScript::kLibrary);
   if (update_lib_status) {
     lib.SetLoadInProgress();
   }
   const Script& script = Script::Handle(Script::New(url, source, kind));
   ASSERT(isolate != NULL);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    Compiler::Compile(lib, script);
+  const Error& error = Error::Handle(Compiler::Compile(lib, script));
+  if (error.IsNull()) {
     *result = Api::NewLocalHandle(lib);
     if (update_lib_status) {
       lib.SetLoaded();
     }
   } else {
-    SetupErrorResult(result);
+    *result = Api::NewLocalHandle(error);
     if (update_lib_status) {
       lib.SetLoadError();
     }
   }
-  isolate->set_long_jump_base(base);
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadScript(Dart_Handle url,
                                         Dart_Handle source,
                                         Dart_LibraryTagHandler handler) {
   TIMERSCOPE(time_script_loading);
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& url_str = Api::UnwrapStringHandle(url);
@@ skipping 51 matching lines @@
                          CURRENT_FUNC);
   }
   library ^= tmp.raw();
   library.Register();
   isolate->object_store()->set_root_library(library);
   return Api::NewLocalHandle(library);
 }
 
 
 static void CompileAll(Isolate* isolate, Dart_Handle* result) {
-  *result = Api::Success();
   ASSERT(isolate != NULL);
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
-    Library::CompileAll();
+  const Error& error = Error::Handle(Library::CompileAll());
+  if (error.IsNull()) {
+    *result = Api::Success();
   } else {
-    SetupErrorResult(result);
+    *result = Api::NewLocalHandle(error);
   }
-  isolate->set_long_jump_base(base);
 }
 
 
 DART_EXPORT Dart_Handle Dart_CompileAll() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Dart_Handle result;
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError(msg);
@@ skipping 171 matching lines @@
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 
 }  // namespace dart