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

runtime/vm/object.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 "vm/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/code_generator.h"
 #include "vm/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
+#include "vm/dart_api_impl.h"

[Ivan Posva, 2011/10/18 20:44:28]

Is this still needed?

[turnidge, 2011/10/18 22:03:12]

Removed.

 #include "vm/debuginfo.h"
 #include "vm/growable_array.h"
 #include "vm/heap.h"
 #include "vm/ic_stubs.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/runtime_entry.h"
 #include "vm/scopes.h"
 #include "vm/timer.h"
 #include "vm/unicode.h"
@@ skipping 39 matching lines @@
 RawClass* Object::script_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_prefix_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::code_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::pc_descriptors_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::exception_handlers_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_scope_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::api_failure_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 #undef RAW_NULL
 
 int Object::GetSingletonClassIndex(const RawClass* raw_class) {
   ASSERT(raw_class->IsHeapObject());
   if (raw_class == class_class()) {
     return kClassClass;
   } else if (raw_class == null_class()) {
     return kNullClass;
   } else if (raw_class == var_class()) {
     return kVarClass;
@@ skipping 30 matching lines @@
   } else if (raw_class == instructions_class()) {
     return kInstructionsClass;
   } else if (raw_class == pc_descriptors_class()) {
     return kPcDescriptorsClass;
   } else if (raw_class == exception_handlers_class()) {
     return kExceptionHandlersClass;
   } else if (raw_class == context_class()) {
     return kContextClass;
   } else if (raw_class == context_scope_class()) {
     return kContextScopeClass;
+  } else if (raw_class == api_failure_class()) {
+    return kApiFailureClass;
   }
   return kInvalidIndex;
 }
 
 
 RawClass* Object::GetSingletonClass(int index) {
   switch (index) {
     case kClassClass: return class_class();
     case kNullClass: return null_class();
     case kVarClass: return var_class();
@@ skipping 11 matching lines @@
     case kTokenStreamClass: return token_stream_class();
     case kScriptClass: return script_class();
     case kLibraryClass: return library_class();
     case kLibraryPrefixClass: return library_prefix_class();
     case kCodeClass: return code_class();
     case kInstructionsClass: return instructions_class();
     case kPcDescriptorsClass: return pc_descriptors_class();
     case kExceptionHandlersClass: return exception_handlers_class();
     case kContextClass: return context_class();
     case kContextScopeClass: return context_scope_class();
+    case kApiFailureClass: return api_failure_class();
     default: break;
   }
   UNREACHABLE();
   return reinterpret_cast<RawClass*>(kHeapObjectTag);  // return RAW_NULL.
 }
 
 
 const char* Object::GetSingletonClassName(int index) {
   switch (index) {
     case kClassClass: return "Class";
@@ skipping 12 matching lines @@
     case kTokenStreamClass: return "TokenStream";
     case kScriptClass: return "Script";
     case kLibraryClass: return "Library";
     case kLibraryPrefixClass: return "LibraryPrefix";
     case kCodeClass: return "Code";
     case kInstructionsClass: return "Instructions";
     case kPcDescriptorsClass: return "PcDescriptors";
     case kExceptionHandlersClass: return "ExceptionHandlers";
     case kContextClass: return "Context";
     case kContextScopeClass: return "ContextScope";
+    case kApiFailureClass: return "ApiFailure";
     default: break;
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 void Object::InitOnce() {
   // TODO(iposva): NoGCScope needs to be added here.
   ASSERT(class_class() == null_);
@@ skipping 110 matching lines @@
 
   cls = Class::New<ExceptionHandlers>();
   exception_handlers_class_ = cls.raw();
 
   cls = Class::New<Context>();
   context_class_ = cls.raw();
 
   cls = Class::New<ContextScope>();
   context_scope_class_ = cls.raw();
 
+  cls = Class::New<ApiFailure>();
+  api_failure_class_ = cls.raw();
+
   ASSERT(class_class() != null_);
 }
 
 
 void Object::Init(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
   Type& type = Type::Handle();
@@ skipping 3987 matching lines @@
 void UnhandledException::set_stacktrace(const Instance& stacktrace) const {
   StorePointer(&raw_ptr()->stacktrace_, stacktrace.raw());
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
+RawApiFailure* ApiFailure::New(const String& message,
+                               Heap::Space space) {

[Ivan Posva, 2011/10/18 20:44:28]

Is a new line needed here?

[turnidge, 2011/10/18 22:03:12]

Removed.

+  const Class& cls = Class::Handle(Object::api_failure_class());
+  ApiFailure& result = ApiFailure::Handle();
+  {
+    RawObject* raw = Object::Allocate(cls,
+                                      ApiFailure::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_message(message);
+  return result.raw();
+}
+
+
+void ApiFailure::set_message(const String& message) const {
+  StorePointer(&raw_ptr()->message_, message.raw());
+}
+
+
+const char* ApiFailure::ToCString() const {
+  return "ApiFailure";
+}
+

[Ivan Posva, 2011/10/18 20:44:28]

new line

[turnidge, 2011/10/18 22:03:12]

Done.

 bool Instance::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     return true;  // "===".
   }
 
   if (other.IsNull() || (this->clazz() != other.clazz())) {
     return false;
   }
 
   {
@@ skipping 2021 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart