Use the distinguished class, ApiFailure, to signal when a Dart_Result is

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"
 
 namespace dart {
 
+DART_EXPORT bool Dart_IsValidResult(const Dart_Result& result) {
+  ASSERT(Isolate::Current() != NULL);
+  if (result.type_ == kRetObject) {
+    Zone zone;  // Setup a VM zone as we are creating some handles.
+    HandleScope scope;  // Setup a VM handle scope.
+
+    // Make sure that the object isn't an ApiFailure.
+    const Object& obj =
+        Object::Handle(Api::UnwrapHandle(result.retval_.obj_value));
+    return !obj.IsApiFailure();
+  }
+  return true;
+}
+
+DART_EXPORT const char* Dart_GetErrorCString(const Dart_Result& result) {
+  ASSERT(Isolate::Current() != NULL);
+  ASSERT(result.type_ == kRetObject);
+  Zone zone;  // Setup a VM zone as we are creating some handles.
+  HandleScope scope;  // Setup a VM handle scope.
+  const Object& obj = Object::Handle(
+      Api::UnwrapHandle(result.retval_.obj_value));
+  if (!obj.IsApiFailure()) {
+    return "";
+  }
+  ApiFailure& failure = ApiFailure::Handle();
+  failure ^= obj.raw();
+  const String& message = String::Handle(failure.message());
+  const char* msg = message.ToCString();
+  intptr_t len = strlen(msg) + 1;
+  char* msg_copy = reinterpret_cast<char*>(Api::Allocate(len));
+  OS::SNPrint(msg_copy, len, "%s", msg);
+  return msg_copy;
+}
+
+
+DART_EXPORT Dart_Result Dart_ErrorResult(const char* value) {
+  ASSERT(Isolate::Current() != NULL);
+
+  Zone zone;  // Setup a VM zone as we are creating some handles.
+  HandleScope scope;  // Setup a VM handle scope.
+  const String& message = String::Handle(String::New(value));
+  const Object& obj = Object::Handle(ApiFailure::New(message));
+
+  Dart_Result result;
+  result.type_ = kRetObject;
+  result.retval_.obj_value = Api::NewLocalHandle(obj);
+  return result;
+}
+
+
 // TODO(iposva): This is a placeholder for the eventual external Dart API.
 DART_EXPORT bool Dart_Initialize(int argc,
                                  char** argv,
                                  Dart_IsolateInitCallback callback) {
   return Dart::InitOnce(argc, argv, callback);
 }
 
 
 DART_EXPORT Dart_Isolate Dart_CreateIsolate(const Dart_Snapshot* snapshot,
                                             void* data) {
@@ skipping 27 matching lines @@
   ASSERT(Isolate::Current() != NULL);
   Isolate::SetCurrent(NULL);
 }
 
 
 static void SetupErrorResult(Dart_Result* result) {
   // Make a copy of the error message as the original message string
   // may get deallocated when we return back from the Dart API call.
   const String& error = String::Handle(
       Isolate::Current()->object_store()->sticky_error());
-  const char* errmsg = error.ToCString();
-  intptr_t errlen = strlen(errmsg) + 1;
-  char* msg = reinterpret_cast<char*>(Api::Allocate(errlen));
-  OS::SNPrint(msg, errlen, "%s", errmsg);
-  result->type_ = kRetError;
-  result->retval_.errmsg = msg;
+  const Object& obj = Object::Handle(ApiFailure::New(error));
+  result->type_ = kRetObject;
+  result->retval_.obj_value = Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT void Dart_SetMessageCallbacks(
     Dart_PostMessageCallback post_message_callback,
     Dart_ClosePortCallback close_port_callback) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ASSERT(post_message_callback != NULL);
   ASSERT(close_port_callback != NULL);
@@ skipping 1055 matching lines @@
     const Object& stacktrace = Object::Handle(unhandled.stacktrace());
     RETURN_OBJECT(stacktrace);
   }
   RETURN_FAILURE("Object is not an unhandled exception object");
 }
 
 
 DART_EXPORT Dart_Result Dart_ThrowException(Dart_Handle exception) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
+  Zone zone;  // Setup a VM zone as we are creating some handles.
+  HandleScope scope;  // Setup a VM handle scope.
   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_FAILURE("No Dart frames on stack, cannot throw exception");
   }
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
   const Instance& excp = Instance::CheckedHandle(Api::UnwrapHandle(exception));
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   state->UnwindScopes(isolate->top_exit_frame_info());
   Exceptions::Throw(excp);
   RETURN_FAILURE("Exception was not thrown, internal error");
 }
 
@@ skipping 496 matching lines @@
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   return scope->zone().Reallocate(ptr, old_size, new_size);
 }
 
 
 }  // namespace dart