Check for presence of native resolver in library for classes which have native fields only in reg...

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 423 matching lines @@
     } else {
       SetupErrorResult(result);
     }
     isolate->set_long_jump_base(base);
   }
 }
 
 
 // Return error if isolate is in an inconsistent state.
 // Return NULL when no error condition exists.
-static const char* CheckIsolateState(Isolate* isolate) {
-  if (!ClassFinalizer::FinalizePendingClasses()) {
+static const char* CheckIsolateState(Isolate* isolate,
+                                     bool generating_snapshot) {

[Ivan Posva, 2011/11/22 00:42:53]

This is almost a default parameter value.

[siva, 2011/11/22 01:19:37]

Made a default parameter.

On 2011/11/22 00:42:53, Ivan Posva wrote:

+  bool result = (generating_snapshot) ?
+      ClassFinalizer::FinalizePendingClassesForSnapshotCreation() :
+      ClassFinalizer::FinalizePendingClasses();
+  if (!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& err =
     String::Handle(isolate->object_store()->sticky_error());
     const char* errmsg = err.ToCString();
     intptr_t errlen = strlen(errmsg) + 1;
     char* msg = reinterpret_cast<char*>(Api::Allocate(errlen));
     OS::SNPrint(msg, errlen, "%s", errmsg);
     return msg;
   }
   return NULL;
 }
 
 
 DART_EXPORT Dart_Handle Dart_CompileAll() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Dart_Handle result;
-  const char* msg = CheckIsolateState(isolate);
+  const char* msg = CheckIsolateState(isolate,
+                                      ClassFinalizer::kNotGeneratingSnapshot);
   if (msg != NULL) {
     return Api::Error(msg);
   }
   CompileAll(isolate, &result);
   return result;
 }
 
 
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object) {
   DARTSCOPE(Isolate::Current());
@@ skipping 231 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Class& cls = Class::CheckedHandle(Api::UnwrapHandle(clazz));
   if (cls.IsNull()) {
     return Api::Error("instanceof check against null class");
   }
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   Instance& instance = Instance::Handle();
   instance ^= obj.raw();
   // Finalize all classes.
-  const char* msg = CheckIsolateState(isolate);
+  const char* msg = CheckIsolateState(isolate,
+                                      ClassFinalizer::kNotGeneratingSnapshot);
   if (msg != NULL) {
     return Api::Error(msg);
   }
   const Type& type = Type::Handle(Type::NewNonParameterizedType(cls));
   *value = instance.Is(type);
   return Api::Success();
 }
 
 
 // TODO(iposva): The argument should be an instance.
@@ skipping 764 matching lines @@
 
 
 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);
+  const char* msg = CheckIsolateState(isolate,
+                                      ClassFinalizer::kNotGeneratingSnapshot);
   if (msg != NULL) {
     return Api::Error(msg);
   }
 
   // Now try to resolve and invoke the static function.
   const Library& library =
       Library::CheckedHandle(Api::UnwrapHandle(library_in));
   if (library.IsNull()) {
     return Api::Error("No library specified");
   }
@@ skipping 491 matching lines @@
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateSnapshot(uint8_t** snapshot_buffer,
                                             intptr_t* snapshot_size) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (snapshot_buffer == NULL || snapshot_size == NULL) {
     return Api::Error("Invalid input parameters to Dart_CreateSnapshot");
   }
-  const char* msg = CheckIsolateState(isolate);
+  const char* msg = CheckIsolateState(isolate,
+                                      ClassFinalizer::kGeneratingSnapshot);
   if (msg != NULL) {
     return Api::Error(msg);
   }
   // Since this is only a snapshot the root library should not be set.
   isolate->object_store()->set_root_library(Library::Handle());
   SnapshotWriter writer(true, snapshot_buffer, ApiAllocator);
   writer.WriteFullSnapshot();
   *snapshot_size = writer.Size();
   return Api::Success();
 }
@@ skipping 211 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