Second local mirrors CL.

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 42 matching lines @@
       return dart_handle;                                               \
     } else {                                                            \
       return Api::NewError("%s expects argument '%s' to be of type %s.", \
                            CURRENT_FUNC, #dart_handle, #Type);          \
     }                                                                   \
   } while (0)
 
 
 // Return error if isolate is in an inconsistent state.
 // Return NULL when no error condition exists.
+//
+// TODO(turnidge): Make this function return an error handle directly
+// rather than returning an error string.  The current behavior can
+// cause compilation errors to appear to be api errors.
 const char* CheckIsolateState(Isolate* isolate, bool generating_snapshot) {
   bool success = true;
   if (!ClassFinalizer::AllClassesFinalized()) {
     success = (generating_snapshot) ?
         ClassFinalizer::FinalizePendingClassesForSnapshotCreation() :
         ClassFinalizer::FinalizePendingClasses();
   }
   if (success) {
     success = isolate->object_store()->PreallocateObjects();
     if (success) {
@@ skipping 183 matching lines @@
 
 
 // --- Handles ---
 
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
   return RawObject::IsErrorClassId(Api::ClassId(handle));
 }
 
 
+DART_EXPORT bool Dart_IsApiError(Dart_Handle object) {
+  return Api::ClassId(object) == kApiError;
+}
+
+
+DART_EXPORT bool Dart_IsUnhandledExceptionError(Dart_Handle object) {
+  return Api::ClassId(object) == kUnhandledException;
+}
+
+
+DART_EXPORT bool Dart_IsCompilationError(Dart_Handle object) {
+  return Api::ClassId(object) == kLanguageError;
+}
+
+
+DART_EXPORT bool Dart_IsFatalError(Dart_Handle object) {
+  return Api::ClassId(object) == kUnwindError;
+}
+
+
 DART_EXPORT const char* Dart_GetError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsError()) {
     Error& error = Error::Handle(isolate);
     error ^= obj.raw();
     const char* str = error.ToErrorCString();
     intptr_t len = strlen(str) + 1;
     char* str_copy = reinterpret_cast<char*>(Api::Allocate(isolate, len));
@@ skipping 38 matching lines @@
     error ^= obj.raw();
     return Api::NewHandle(isolate, error.stacktrace());
   } else if (obj.IsError()) {
     return Api::NewError("This error is not an unhandled exception error.");
   } else {
     return Api::NewError("Can only get stacktraces from error handles.");
   }
 }
 
 
+// Deprecated.
+// TODO(turnidge): Remove all uses and delete.
+DART_EXPORT Dart_Handle Dart_Error(const char* format, ...) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+
+  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));
+  va_list args2;
+  va_start(args2, format);
+  OS::VSNPrint(buffer, (len + 1), format, args2);
+  va_end(args2);
+
+  const String& message = String::Handle(isolate, String::New(buffer));
+  return Api::NewHandle(isolate, ApiError::New(message));
+}
+
+
 // TODO(turnidge): This clones Api::NewError.  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, ...) {
+DART_EXPORT Dart_Handle Dart_NewApiError(const char* format, ...) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
 
   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));
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   const String& message = String::Handle(isolate, String::New(buffer));
   return Api::NewHandle(isolate, ApiError::New(message));
 }
 
 
+DART_EXPORT Dart_Handle Dart_NewUnhandledExceptionError(Dart_Handle exception) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Instance& obj = Api::UnwrapInstanceHandle(isolate, exception);
+  if (obj.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, exception, Instance);
+  }
+  const Instance& stacktrace = Instance::Handle(isolate);
+  return Api::NewHandle(isolate, UnhandledException::New(obj, stacktrace));
+}
+
+
 DART_EXPORT Dart_Handle Dart_PropagateError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   const Object& error = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (!error.IsError()) {
     return Api::NewError(
         "%s expects argument 'handle' to be an error handle.  "
         "Did you forget to check Dart_IsError first?",
         CURRENT_FUNC);
   }
@@ skipping 749 matching lines @@
   }
   const Type& type = Type::Handle(isolate, Type::NewNonParameterizedType(cls));
   Error& malformed_type_error = Error::Handle(isolate);
   *value = instance.IsInstanceOf(
       type, TypeArguments::Handle(isolate), &malformed_type_error);
   ASSERT(malformed_type_error.IsNull());  // Type was created here from a class.
   return Api::Success(isolate);
 }
 
 
+// --- Instances ----
+
+
+DART_EXPORT bool Dart_IsInstance(Dart_Handle object) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  return obj.IsInstance();
+}
+
+
+// TODO(turnidge): Technically, null has a class.  Should we allow it?
+DART_EXPORT Dart_Handle Dart_InstanceGetClass(Dart_Handle instance) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Instance& obj = Api::UnwrapInstanceHandle(isolate, instance);
+  if (obj.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, instance, Instance);
+  }
+  return Api::NewHandle(isolate, obj.clazz());
+}
+
+
 // --- Numbers ----
 
 
-// TODO(iposva): The argument should be an instance.
 DART_EXPORT bool Dart_IsNumber(Dart_Handle object) {
   return RawObject::IsNumberClassId(Api::ClassId(object));
 }
 
 
 // --- Integers ----
 
 
 DART_EXPORT bool Dart_IsInteger(Dart_Handle object) {
   return RawObject::IsIntegerClassId(Api::ClassId(object));
@@ skipping 541 matching lines @@
   type& array = type::Handle(isolate);                                         \
   array ^= obj.raw();                                                          \
   *len = array.Length();                                                       \
   return Api::Success(isolate);                                                \
 
 
 DART_EXPORT Dart_Handle Dart_ListLength(Dart_Handle list, intptr_t* len) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
+  if (obj.IsError()) {
+    // Pass through errors.
+    return list;
+  }
   if (obj.IsByteArray()) {
     GET_LIST_LENGTH(isolate, ByteArray, obj, len);
   }
   if (obj.IsArray()) {
     GET_LIST_LENGTH(isolate, Array, obj, len);
   }
   if (obj.IsGrowableObjectArray()) {
     GET_LIST_LENGTH(isolate, GrowableObjectArray, obj, len);
   }
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance =
       Instance::Handle(isolate, GetListInstance(isolate, obj));
   if (instance.IsNull()) {
-    return Api::NewError("Object does not implement the List inteface");
+    return Api::NewError("Object does not implement the List interface");
   }
   String& name = String::Handle(isolate, String::New("length"));
   name = Field::GetterName(name);
   const Function& function =
       Function::Handle(isolate, Resolver::ResolveDynamic(instance, name, 1, 0));
   if (function.IsNull()) {
     return Api::NewError("List object does not have a 'length' field.");
   }
 
   GrowableArray<const Object*> args(0);
@@ skipping 576 matching lines @@
 DART_EXPORT void Dart_ClosureSetSmrck(Dart_Handle object, int64_t value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Closure& obj =
       Closure::CheckedHandle(isolate, Api::UnwrapHandle(object));
   const Integer& smrck = Integer::Handle(isolate, Integer::New(value));
   obj.set_smrck(smrck);
 }
 
 
+// --- Classes and Interfaces ---
+
+
+DART_EXPORT bool Dart_IsClass(Dart_Handle handle) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
+  if (obj.IsClass()) {
+    Class& cls = Class::Handle(isolate);
+    cls ^= obj.raw();
+    return !cls.is_interface();
+  }
+  return false;
+}
+
+
+DART_EXPORT bool Dart_IsInterface(Dart_Handle handle) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
+  if (obj.IsClass()) {
+    Class& cls = Class::Handle(isolate);
+    cls ^= obj.raw();
+    return cls.is_interface();
+  }
+  return false;
+}
+
+
+DART_EXPORT Dart_Handle Dart_ClassName(Dart_Handle clazz) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Class& cls = Class::Handle(isolate);
+  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+  return Api::NewHandle(isolate, cls.Name());
+}
+
+
+DART_EXPORT Dart_Handle Dart_ClassGetLibrary(Dart_Handle clazz) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Class& cls = Class::Handle(isolate);
+  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+  return Api::NewHandle(isolate, cls.library());
+}
+
+
+DART_EXPORT Dart_Handle Dart_ClassGetDefault(Dart_Handle clazz) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Class& cls = Class::Handle(isolate);
+  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+
+  // Finalize all classes.
+  const char* msg = CheckIsolateState(isolate);
+  if (msg != NULL) {
+    return Api::NewError(msg);
+  }
+
+  if (cls.HasFactoryClass() && cls.HasResolvedFactoryClass()) {
+    return Api::NewHandle(isolate, cls.FactoryClass());
+  }
+  return Api::Null(isolate);
+}
+
+
+DART_EXPORT Dart_Handle Dart_ClassGetInterfaceCount(Dart_Handle clazz,
+                                                    intptr_t* count) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Class& cls = Class::Handle(isolate);
+  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+
+  const Array& interface_types = Array::Handle(isolate, cls.interfaces());
+  if (interface_types.IsNull()) {
+    *count = 0;
+  } else {
+    *count = interface_types.Length();
+  }
+  return Api::Success(isolate);
+}
+
+
+DART_EXPORT Dart_Handle Dart_ClassGetInterfaceAt(Dart_Handle clazz,
+                                                 intptr_t index) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  Class& cls = Class::Handle(isolate);
+  cls ^= Api::UnwrapClassHandle(isolate, clazz).raw();
+  if (cls.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, clazz, Class);
+  }
+
+  // Finalize all classes.
+  const char* msg = CheckIsolateState(isolate);
+  if (msg != NULL) {
+    return Api::NewError(msg);
+  }
+
+  const Array& interface_types = Array::Handle(isolate, cls.interfaces());
+  if (index < 0 || index >= interface_types.Length()) {
+    return Api::NewError("%s: argument 'index' out of bounds.", CURRENT_FUNC);
+  }
+  Type& interface_type = Type::Handle(isolate);
+  interface_type ^= interface_types.At(index);
+  if (interface_type.HasResolvedTypeClass()) {
+    return Api::NewHandle(isolate, interface_type.type_class());
+  }
+  const String& type_name =
+      String::Handle(isolate, interface_type.TypeClassName());
+  return Api::NewError("%s: internal error: found unresolved type class '%s'.",
+                       CURRENT_FUNC, type_name.ToCString());
+}
+
+
 // --- Constructors, Methods, and Fields ---
 
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
                                      const String& dotted_name,
                                      int num_args) {
   // The constructor must be present in the interface.
   String& constr_name = String::Handle(String::Concat(class_name, dotted_name));
@@ skipping 138 matching lines @@
     args.Add(&TypeArguments::Handle(isolate));
   }
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg =
         Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
     if (!arg.IsNull() && !arg.IsInstance()) {
       if (arg.IsError()) {
         return Api::NewHandle(isolate, arg.raw());
       } else {
         return Api::NewError(
-            "%s expects argument %d to be an instance of Object.",
+            "%s expects arguments[%d] to be an Instance handle.",
             CURRENT_FUNC, i);
       }
     }
     args.Add(&arg);
   }
 
   // Invoke the constructor and return the new object.
   const Array& kNoArgNames = Array::Handle(isolate);
   result = DartEntry::InvokeStatic(constructor, args, kNoArgNames);
   if (result.IsError()) {
@@ skipping 29 matching lines @@
   // Check for malformed arguments in the arguments list.
   GrowableArray<const Object*> args(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg =
         Object::Handle(isolate, Api::UnwrapHandle(arguments[i]));
     if (!arg.IsNull() && !arg.IsInstance()) {
       if (arg.IsError()) {
         return Api::NewHandle(isolate, arg.raw());
       } else {
         return Api::NewError(
-            "%s expects argument %d to be an instance of Object.",
+            "%s expects arguments[%d] to be an Instance handle.",
             CURRENT_FUNC, i);
       }
     }
     args.Add(&arg);
   }
 
   const Array& kNoArgNames = Array::Handle(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(target));
   if (obj.IsError()) {
     return target;
@@ skipping 733 matching lines @@
   const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
   if (lib.IsNull()) {
     RETURN_TYPE_ERROR(isolate, library, Library);
   }
   const String& url = String::Handle(isolate, lib.url());
   ASSERT(!url.IsNull());
   return Api::NewHandle(isolate, url.raw());
 }
 
 
+DART_EXPORT Dart_Handle Dart_LibraryGetClassNames(Dart_Handle library) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
+  if (lib.IsNull()) {
+    RETURN_TYPE_ERROR(isolate, library, Library);
+  }
+
+  const GrowableObjectArray& names =
+      GrowableObjectArray::Handle(isolate, GrowableObjectArray::New());
+  ClassDictionaryIterator it(lib);
+  Class& cls = Class::Handle();
+  String& name = String::Handle();
+  while (it.HasNext()) {
+    cls = it.GetNextClass();
+    name = cls.Name();
+    names.Add(name);
+  }
+  return Api::NewHandle(isolate, Array::MakeArray(names));
+}
+
+
 DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& url_str = Api::UnwrapStringHandle(isolate, url);
   if (url_str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, url, String);
   }
   const Library& library =
       Library::Handle(isolate, Library::LookupLibrary(url_str));
   if (library.IsNull()) {
@@ skipping 137 matching lines @@
     *buffer_size = 0;
   }
 }
 
 
 DART_EXPORT void Dart_InitFlowGraphPrinting(FileWriterFunction function) {
   Dart::set_flow_graph_writer(function);
 }
 
 }  // namespace dart