VM thread shutdown.

runtime/bin/dartutils.cc

 // Copyright (c) 2012, 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 "bin/dartutils.h"
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "platform/globals.h"
 
 #include "bin/crypto.h"
 #include "bin/directory.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
 #include "bin/io_buffer.h"
 #include "bin/isolate_data.h"
 #include "bin/platform.h"
 #include "bin/socket.h"
 #include "bin/utils.h"
 
+// Return the error from the containing function if handle is in error handle.
+#define RETURN_IF_ERROR(handle)                                                \
+  {                                                                            \
+    Dart_Handle __handle = handle;                                             \
+    if (Dart_IsError((__handle))) {                                            \
+      return __handle;                                                         \
+    }                                                                          \
+  }
+
 namespace dart {
 namespace bin {
 
 const char* DartUtils::original_working_directory = NULL;
 const char* DartUtils::kDartScheme = "dart:";
 const char* DartUtils::kDartExtensionScheme = "dart-ext:";
 const char* DartUtils::kAsyncLibURL = "dart:async";
 const char* DartUtils::kBuiltinLibURL = "dart:_builtin";
 const char* DartUtils::kCoreLibURL = "dart:core";
 const char* DartUtils::kInternalLibURL = "dart:_internal";
@@ skipping 85 matching lines @@
 
 
 bool DartUtils::GetBooleanValue(Dart_Handle bool_obj) {
   bool value = false;
   Dart_Handle result = Dart_BooleanValue(bool_obj, &value);
   if (Dart_IsError(result)) Dart_PropagateError(result);
   return value;
 }
 
 
-void DartUtils::SetIntegerField(Dart_Handle handle,
-                                const char* name,
-                                int64_t val) {
-  Dart_Handle result = Dart_SetField(handle,
-                                     NewString(name),
-                                     Dart_NewInteger(val));
-  if (Dart_IsError(result)) Dart_PropagateError(result);
+Dart_Handle DartUtils::SetIntegerField(Dart_Handle handle,
+                                       const char* name,
+                                       int64_t val) {
+  return Dart_SetField(handle, NewString(name), Dart_NewInteger(val));
 }
 
 
-void DartUtils::SetStringField(Dart_Handle handle,
+Dart_Handle DartUtils::SetStringField(Dart_Handle handle,
                                const char* name,
                                const char* val) {
-  Dart_Handle result = Dart_SetField(handle, NewString(name), NewString(val));
-  if (Dart_IsError(result)) Dart_PropagateError(result);
+  return Dart_SetField(handle, NewString(name), NewString(val));
 }
 
 
 bool DartUtils::IsDartSchemeURL(const char* url_name) {
   static const intptr_t kDartSchemeLen = strlen(kDartScheme);
   // If the URL starts with "dart:" then it is considered as a special
   // library URL which is handled differently from other URLs.
   return (strncmp(url_name, kDartScheme, kDartSchemeLen) == 0);
 }
 
@@ skipping 222 matching lines @@
   // Handle URI canonicalization requests.
   if (tag == Dart_kCanonicalizeUrl) {
     // If this is a Dart Scheme URL or 'part' of a io library
     // then it is not modified as it will be handled internally.
     if (is_dart_scheme_url || is_io_library) {
       return url;
     }
     // Resolve the url within the context of the library's URL.
     Dart_Handle builtin_lib =
         Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
-    DART_CHECK_VALID(builtin_lib);
+    RETURN_IF_ERROR(builtin_lib);
     return ResolveUri(library_url, url, builtin_lib);
   }
 
   // Handle 'import' of dart scheme URIs (i.e they start with 'dart:').
   if (is_dart_scheme_url) {
     if (tag == Dart_kImportTag) {
       // Handle imports of other built-in libraries present in the SDK.
       if (DartUtils::IsDartIOLibURL(url_string)) {
         return Builtin::LoadLibrary(url, Builtin::kIOLibrary);
       }
@@ skipping 19 matching lines @@
           part_uri_obj,
           Builtin::PartSource(Builtin::kIOLibrary, url_string), 0, 0);
     } else {
       ASSERT(tag == Dart_kImportTag);
       return NewError("Unable to import '%s' ", url_string);
     }
   }
 
   Dart_Handle builtin_lib =
       Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
-  DART_CHECK_VALID(builtin_lib);
+  RETURN_IF_ERROR(builtin_lib);
   if (DartUtils::IsDartExtensionSchemeURL(url_string)) {
     // Load a native code shared library to use in a native extension
     if (tag != Dart_kImportTag) {
       return NewError("Dart extensions must use import: '%s'", url_string);
     }
     Dart_Handle path_parts = DartUtils::ExtensionPathFromUri(url, builtin_lib);
     if (Dart_IsError(path_parts)) {
       return path_parts;
     }
     const char* extension_directory = NULL;
@@ skipping 125 matching lines @@
     Dart_Handle source = Dart_NewStringFromUTF8(data, num_bytes);
     if (Dart_IsError(source)) {
       result = DartUtils::NewError("%s is not a valid UTF-8 script",
                                    resolved_script_uri);
     } else {
       if (tag == Dart_kImportTag) {
         result = Dart_LoadLibrary(resolved_script_uri, source, 0, 0);
       } else {
         ASSERT(tag == Dart_kSourceTag);
         Dart_Handle library = Dart_LookupLibrary(library_uri);
-        DART_CHECK_VALID(library);
+        if (Dart_IsError(library)) {
+          Dart_PropagateError(library);
+        }
         result = Dart_LoadSource(library, resolved_script_uri, source, 0, 0);
       }
     }
   }
 
   if (buffer_copy != NULL) {
     free(const_cast<uint8_t *>(buffer_copy));
   }
 
   if (Dart_IsError(result)) {
@@ skipping 40 matching lines @@
 
 Dart_Handle DartUtils::PrepareBuiltinLibrary(Dart_Handle builtin_lib,
                                              Dart_Handle internal_lib,
                                              bool is_service_isolate,
                                              bool trace_loading,
                                              const char* package_root,
                                              const char* packages_file) {
   // Setup the internal library's 'internalPrint' function.
   Dart_Handle print = Dart_Invoke(
       builtin_lib, NewString("_getPrintClosure"), 0, NULL);
-  DART_CHECK_VALID(print);
+  RETURN_IF_ERROR(print);
   Dart_Handle result =
       Dart_SetField(internal_lib, NewString("_printClosure"), print);
-  DART_CHECK_VALID(result);
+  RETURN_IF_ERROR(result);
 
   if (!is_service_isolate) {
     if (IsWindowsHost()) {
       result = Dart_SetField(builtin_lib, NewString("_isWindows"), Dart_True());
-      DART_CHECK_VALID(result);
+      RETURN_IF_ERROR(result);
     }
     if (trace_loading) {
       result = Dart_SetField(builtin_lib,
                              NewString("_traceLoading"), Dart_True());
-      DART_CHECK_VALID(result);
+      RETURN_IF_ERROR(result);
     }
     // Set current working directory.
     result = SetWorkingDirectory(builtin_lib);
-    DART_CHECK_VALID(result);
+    RETURN_IF_ERROR(result);
     // Wait for the service isolate to initialize the load port.
     Dart_Port load_port = Dart_ServiceWaitForLoadPort();
     if (load_port == ILLEGAL_PORT) {
       return NewDartUnsupportedError("Service did not return load port.");
     }
-    Builtin::SetLoadPort(load_port);
+    result = Builtin::SetLoadPort(load_port);
+    RETURN_IF_ERROR(result);
   }
 
   // Set up package root if specified.
   if (package_root != NULL) {
     ASSERT(packages_file == NULL);
     result = NewString(package_root);
-    DART_CHECK_VALID(result);
+    RETURN_IF_ERROR(result);
     const int kNumArgs = 1;
     Dart_Handle dart_args[kNumArgs];
     dart_args[0] = result;
     result = Dart_Invoke(builtin_lib,
                          NewString("_setPackageRoot"),
                          kNumArgs,
                          dart_args);
-    DART_CHECK_VALID(result);
+    RETURN_IF_ERROR(result);
   } else if (packages_file != NULL) {
     result = NewString(packages_file);
-    DART_CHECK_VALID(result);
+    RETURN_IF_ERROR(result);
     const int kNumArgs = 1;
     Dart_Handle dart_args[kNumArgs];
     dart_args[0] = result;
     result = Dart_Invoke(builtin_lib,
                          NewString("_loadPackagesMap"),
                          kNumArgs,
                          dart_args);
-    DART_CHECK_VALID(result);
+    RETURN_IF_ERROR(result);
   }
   return Dart_True();
 }
 
 
-void DartUtils::PrepareCoreLibrary(Dart_Handle core_lib,
-                                   Dart_Handle builtin_lib,
-                                   bool is_service_isolate) {
+Dart_Handle DartUtils::PrepareCoreLibrary(Dart_Handle core_lib,
+                                          Dart_Handle builtin_lib,
+                                          bool is_service_isolate) {
   if (!is_service_isolate) {
     // Setup the 'Uri.base' getter in dart:core.
     Dart_Handle uri_base = Dart_Invoke(
         builtin_lib, NewString("_getUriBaseClosure"), 0, NULL);
-    DART_CHECK_VALID(uri_base);
+    RETURN_IF_ERROR(uri_base);
     Dart_Handle result = Dart_SetField(core_lib,
                                        NewString("_uriBaseClosure"),
                                        uri_base);
-    DART_CHECK_VALID(result);
+    RETURN_IF_ERROR(result);
   }
+  return Dart_True();
 }
 
 
-void DartUtils::PrepareAsyncLibrary(Dart_Handle async_lib,
-                                    Dart_Handle isolate_lib) {
+Dart_Handle DartUtils::PrepareAsyncLibrary(Dart_Handle async_lib,
+                                           Dart_Handle isolate_lib) {
   Dart_Handle schedule_immediate_closure =
       Dart_Invoke(isolate_lib, NewString("_getIsolateScheduleImmediateClosure"),
                   0, NULL);
+  RETURN_IF_ERROR(schedule_immediate_closure);
   Dart_Handle args[1];
   args[0] = schedule_immediate_closure;
-  DART_CHECK_VALID(Dart_Invoke(
-      async_lib, NewString("_setScheduleImmediateClosure"), 1, args));
+  return Dart_Invoke(
+      async_lib, NewString("_setScheduleImmediateClosure"), 1, args);
 }
 
 
-void DartUtils::PrepareIOLibrary(Dart_Handle io_lib) {
-  DART_CHECK_VALID(Dart_Invoke(io_lib, NewString("_setupHooks"), 0, NULL));
+Dart_Handle DartUtils::PrepareIOLibrary(Dart_Handle io_lib) {
+  return Dart_Invoke(io_lib, NewString("_setupHooks"), 0, NULL);
 }
 
 
-void DartUtils::PrepareIsolateLibrary(Dart_Handle isolate_lib) {
-  DART_CHECK_VALID(Dart_Invoke(isolate_lib, NewString("_setupHooks"), 0, NULL));
+Dart_Handle DartUtils::PrepareIsolateLibrary(Dart_Handle isolate_lib) {
+  return Dart_Invoke(isolate_lib, NewString("_setupHooks"), 0, NULL);
 }
 
 
 Dart_Handle DartUtils::PrepareForScriptLoading(const char* package_root,
                                                const char* packages_file,
                                                bool is_service_isolate,
                                                bool trace_loading,
                                                Dart_Handle builtin_lib) {
   // First ensure all required libraries are available.
   Dart_Handle url = NewString(kCoreLibURL);
-  DART_CHECK_VALID(url);
+  RETURN_IF_ERROR(url);
   Dart_Handle core_lib = Dart_LookupLibrary(url);
-  DART_CHECK_VALID(core_lib);
+  RETURN_IF_ERROR(core_lib);
   url = NewString(kAsyncLibURL);
-  DART_CHECK_VALID(url);
+  RETURN_IF_ERROR(url);
   Dart_Handle async_lib = Dart_LookupLibrary(url);
-  DART_CHECK_VALID(async_lib);
+  RETURN_IF_ERROR(async_lib);
   url = NewString(kIsolateLibURL);
-  DART_CHECK_VALID(url);
+  RETURN_IF_ERROR(url);
   Dart_Handle isolate_lib = Dart_LookupLibrary(url);
-  DART_CHECK_VALID(isolate_lib);
+  RETURN_IF_ERROR(isolate_lib);
   url = NewString(kInternalLibURL);
-  DART_CHECK_VALID(url);
+  RETURN_IF_ERROR(url);
   Dart_Handle internal_lib = Dart_LookupLibrary(url);
-  DART_CHECK_VALID(internal_lib);
+  RETURN_IF_ERROR(internal_lib);
   Dart_Handle io_lib = Builtin::LoadAndCheckLibrary(Builtin::kIOLibrary);
-  DART_CHECK_VALID(io_lib);
+  RETURN_IF_ERROR(io_lib);
 
   // We need to ensure that all the scripts loaded so far are finalized
   // as we are about to invoke some Dart code below to setup closures.
   Dart_Handle result = Dart_FinalizeLoading(false);
-  DART_CHECK_VALID(result);
+  RETURN_IF_ERROR(result);
 
   result = PrepareBuiltinLibrary(builtin_lib,
                                  internal_lib,
                                  is_service_isolate,
                                  trace_loading,
                                  package_root,
                                  packages_file);
-  DART_CHECK_VALID(result);
+  RETURN_IF_ERROR(result);
 
-  PrepareAsyncLibrary(async_lib, isolate_lib);
-  PrepareCoreLibrary(core_lib, builtin_lib, is_service_isolate);
-  PrepareIsolateLibrary(isolate_lib);
-  PrepareIOLibrary(io_lib);
+  RETURN_IF_ERROR(PrepareAsyncLibrary(async_lib, isolate_lib));
+  RETURN_IF_ERROR(PrepareCoreLibrary(
+      core_lib, builtin_lib, is_service_isolate));
+  RETURN_IF_ERROR(PrepareIsolateLibrary(isolate_lib));
+  RETURN_IF_ERROR(PrepareIOLibrary(io_lib));
   return result;
 }
 
 
-void DartUtils::SetupIOLibrary(const char* script_uri) {
+Dart_Handle DartUtils::SetupIOLibrary(const char* script_uri) {
   Dart_Handle io_lib_url = NewString(kIOLibURL);
-  DART_CHECK_VALID(io_lib_url);
+  RETURN_IF_ERROR(io_lib_url);
   Dart_Handle io_lib = Dart_LookupLibrary(io_lib_url);
-  DART_CHECK_VALID(io_lib);
+  RETURN_IF_ERROR(io_lib);
   Dart_Handle platform_type = GetDartType(DartUtils::kIOLibURL, "_Platform");
-  DART_CHECK_VALID(platform_type);
+  RETURN_IF_ERROR(platform_type);
   Dart_Handle script_name = NewString("_nativeScript");
-  DART_CHECK_VALID(script_name);
+  RETURN_IF_ERROR(script_name);
   Dart_Handle dart_script = NewString(script_uri);
-  DART_CHECK_VALID(dart_script);
+  RETURN_IF_ERROR(dart_script);
   Dart_Handle set_script_name =
       Dart_SetField(platform_type, script_name, dart_script);
-  DART_CHECK_VALID(set_script_name);
+  RETURN_IF_ERROR(set_script_name);
+  return Dart_Null();
 }
 
 
 bool DartUtils::PostNull(Dart_Port port_id) {
   // Post a message with just the null object.
   return Dart_PostCObject(port_id, CObject::Null()->AsApiCObject());
 }
 
 
 bool DartUtils::PostInt32(Dart_Port port_id, int32_t value) {
@@ skipping 428 matching lines @@
       new CObjectString(CObject::NewString(os_error->message()));
   CObjectArray* result = new CObjectArray(CObject::NewArray(3));
   result->SetAt(0, new CObjectInt32(CObject::NewInt32(kOSError)));
   result->SetAt(1, new CObjectInt32(CObject::NewInt32(os_error->code())));
   result->SetAt(2, error_message);
   return result;
 }
 
 }  // namespace bin
 }  // namespace dart