If an unhandled exception occurs in Dart_RunLoop, pass it out to the caller.

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 660 matching lines @@
     Dart_ClosePortCallback close_port_callback) {
   Isolate* isolate = Isolate::Current();
   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);
 }
 
 
+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.IsUnhandledException()) {
+      result = Api::ErrorFromException(obj);
+    } else {
+      ASSERT(obj.IsNull());
+      result = Api::Success();
+    }
+  } else {
+    SetupErrorResult(&result);
+  }
+  isolate->set_long_jump_base(base);
+  return result;
+}
+
+
 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.
   Isolate* isolate = Isolate::Current();
   SnapshotReader reader(snapshot, isolate->heap(), isolate->object_store());
   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));
-  const String& class_name =
-      String::Handle(String::NewSymbol("ReceivePortImpl"));
-  const String& function_name =
-      String::Handle(String::NewSymbol("_handleMessage"));
-  const int kNumArguments = 3;
-  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(dest_port_id)));
-  arguments.Add(&Integer::Handle(Integer::New(reply_port_id)));
-  arguments.Add(&msg);
-  // TODO(turnidge): This call should be wrapped in a longjmp
-  const Object& result = Object::Handle(
-      DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
+  // TODO(turnidge): Should this call should be wrapped in a longjmp?

[tobyr, 2011/12/14 17:48:32]

s/should be/be

[turnidge, 2011/12/14 18:26:55]

Done.

+  const Object& result =
+      Object::Handle(DartLibraryCalls::HandleMessage(dest_port_id,
+                                                     reply_port_id,
+                                                     msg));
   if (result.IsUnhandledException()) {
     return Api::ErrorFromException(result);
   }
   ASSERT(result.IsNull());
   return Api::Success();
 }
 
 
-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) {
-    isolate->StandardRunLoop();
-    result = Api::Success();
-  } else {
-    SetupErrorResult(&result);
-  }
-  isolate->set_long_jump_base(base);
-  return result;
-}
-
-
 DART_EXPORT bool Dart_HasLivePorts() {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate);
   return isolate->live_ports() > 0;
 }
 
 
 static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
@@ skipping 1756 matching lines @@
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 
 }  // namespace dart