Add a mid-sized integration test for the Dart Embedding Api which

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 67 matching lines @@
 static void SetupErrorResult(Dart_Handle* handle) {
   // 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 Object& obj = Object::Handle(ApiError::New(error));
   *handle = Api::NewLocalHandle(obj);
 }
 
 
+// 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));
+    if (retval.IsUnhandledException()) {
+      *result = Api::ErrorFromException(retval);
+    } else {
+      *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));
+    if (retval.IsUnhandledException()) {
+      *result = Api::ErrorFromException(retval);
+    } else {
+      *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 254 matching lines @@
       return Api::NewLocalHandle(stacktrace);
     } else {
       return Api::Error("This error is not an unhandled exception error.");
     }
   } else {
     return Api::Error("Can only get stacktraces from error handles.");
   }
 }
 
 
-// TODO(turnidge): This clonse Api::Error.  I need to use va_copy to
+// TODO(turnidge): This clones Api::Error.  I need to use va_copy to
 // fix this but not sure if it available on all of our builds.
 DART_EXPORT Dart_Handle Dart_Error(const char* format, ...) {
   DARTSCOPE(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));
@@ skipping 215 matching lines @@
   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,
                                            Dart_Port reply_port,
                                            Dart_Message dart_message) {
-  DARTSCOPE(Isolate::Current());
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);

[siva, 2011/11/24 00:52:31]

The isolate variable is not used in this method is there a need to have a
isolate variable.

[turnidge, 2011/11/29 01:01:31]

Fixed.

 
   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_"));
+      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)));
   arguments.Add(&Integer::Handle(Integer::New(reply_port)));
   arguments.Add(&msg);
+  // TODO(turnidge): This call should be wrapped in a longjmp
   const Object& result = Object::Handle(
       DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
   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();
+  DARTSCOPE(isolate);
+  const String& class_name =
+      String::Handle(String::NewSymbol("ReceivePortImpl"));
+  const String& function_name =
+      String::Handle(String::NewSymbol("_getNumLivePorts"));
+  const int kNumArguments = 0;
+  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);
+
+  Dart_EnterScope();

[siva, 2011/11/24 00:52:31]

Why is a Dart_EnterScope needed here? Normally we have assumed that people
calling into the dart api functions would have a scope setup.

[turnidge, 2011/11/29 01:01:31]

Completely redid how this works.

+  Dart_Handle result;
+  InvokeStatic(isolate, function, arguments, &result);
+  const Integer& count = Api::UnwrapIntegerHandle(result);
+  Dart_ExitScope();
+
+  return count.AsInt64Value() > 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);
 }
 
 
 DART_EXPORT bool Dart_PostIntArray(Dart_Port port,
                                    intptr_t len,
                                    intptr_t* data) {
   uint8_t* buffer = NULL;
@@ skipping 10 matching lines @@
   DARTSCOPE(Isolate::Current());
   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, kNoReplyPort, data);
 }
 
 
+DART_EXPORT Dart_Handle Dart_NewSendPort(Dart_Port port) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const String& class_name = String::Handle(String::NewSymbol("SendPortImpl"));
+  const String& function_name = String::Handle(String::NewSymbol("_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)));
+  Dart_Handle result;
+  InvokeStatic(isolate, function, arguments, &result);
+  return result;
+}
+
+
+DART_EXPORT Dart_Handle Dart_NewReceivePort(Dart_Port port) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const String& class_name =
+      String::Handle(String::NewSymbol("ReceivePortImpl"));
+  const String& function_name = String::Handle(String::NewSymbol("_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));

[siva, 2011/11/24 00:52:31]

The function resolution code seems to be identical and repeated many times, I am
wondering if it would be possible to have a static function that takes a class
name and a function name and returns a RawFunction.

[turnidge, 2011/11/29 01:01:31]

Added a TODO.  Is that okay?

On 2011/11/24 00:52:31, asiva wrote:

+  GrowableArray<const Object*> arguments(kNumArguments);
+  arguments.Add(&Integer::Handle(Integer::New(port)));
+  Dart_Handle result;
+  InvokeStatic(isolate, function, arguments, &result);
+  return result;
+}
+
+
+DART_EXPORT Dart_Port Dart_GetMainPort() {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate);
+  return isolate->main_port();
+}
+
 // --- Scopes ----
 
 
 DART_EXPORT void Dart_EnterScope() {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* new_scope = new ApiLocalScope(state->top_scope(),
                                                reinterpret_cast<uword>(&state));
@@ skipping 855 matching lines @@
   DARTSCOPE(Isolate::Current());
   const Closure& obj = Closure::CheckedHandle(Api::UnwrapHandle(object));
   const Integer& smrck = Integer::Handle(Integer::New(value));
   obj.set_smrck(smrck);
 }
 
 
 // --- Methods and Fields ---
 
 
-// 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));
-    if (retval.IsUnhandledException()) {
-      *result = Api::ErrorFromException(retval);
-    } else {
-      *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));
-    if (retval.IsUnhandledException()) {
-      *result = Api::ErrorFromException(retval);
-    } else {
-      *result = Api::NewLocalHandle(retval);
-    }
-  } else {
-    SetupErrorResult(result);
-  }
-  isolate->set_long_jump_base(base);
-}
-
-
 DART_EXPORT Dart_Handle Dart_InvokeStatic(Dart_Handle library_in,
                                           Dart_Handle class_name_in,
                                           Dart_Handle function_name_in,
                                           int number_of_arguments,
                                           Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
@@ skipping 678 matching lines @@
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 
 }  // namespace dart