Introduce the Error object class in the vm. It represents all of the

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"
@@ skipping 58 matching lines @@
 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::var_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_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::language_error_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::unhandled_exception_class_ =
+    reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::unwind_error_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 == dynamic_class()) {
     return kDynamicClass;
@@ skipping 34 matching lines @@
   } else if (raw_class == var_descriptors_class()) {
     return kLocalVarDescriptorsClass;
   } 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_error_class()) {
     return kApiErrorClass;
+  } else if (raw_class == language_error_class()) {
+    return kLanguageErrorClass;
+  } else if (raw_class == unhandled_exception_class()) {
+    return kUnhandledExceptionClass;
+  } else if (raw_class == unwind_error_class()) {
+    return kUnwindErrorClass;
   }
   return kInvalidIndex;
 }
 
 
 RawClass* Object::GetSingletonClass(int index) {
   switch (index) {
     case kClassClass: return class_class();
     case kNullClass: return null_class();
     case kDynamicClass: return dynamic_class();
@@ skipping 13 matching lines @@
     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 kLocalVarDescriptorsClass: return var_descriptors_class();
     case kExceptionHandlersClass: return exception_handlers_class();
     case kContextClass: return context_class();
     case kContextScopeClass: return context_scope_class();
     case kApiErrorClass: return api_error_class();
+    case kLanguageErrorClass: return language_error_class();
+    case kUnhandledExceptionClass: return unhandled_exception_class();
+    case kUnwindErrorClass: return unwind_error_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 14 matching lines @@
     case kLibraryClass: return "Library";
     case kLibraryPrefixClass: return "LibraryPrefix";
     case kCodeClass: return "Code";
     case kInstructionsClass: return "Instructions";
     case kPcDescriptorsClass: return "PcDescriptors";
     case kLocalVarDescriptorsClass: return "LocalVarDescriptors";
     case kExceptionHandlersClass: return "ExceptionHandlers";
     case kContextClass: return "Context";
     case kContextScopeClass: return "ContextScope";
     case kApiErrorClass: return "ApiError";
+    case kLanguageErrorClass: return "LanguageError";
+    case kUnhandledExceptionClass: return "UnhandledException";
+    case kUnwindErrorClass: return "UnwindError";
     default: break;
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 void Object::InitOnce() {
   // TODO(iposva): NoGCScope needs to be added here.
   ASSERT(class_class() == null_);
@@ skipping 126 matching lines @@
 
   cls = Class::New<Context>();
   context_class_ = cls.raw();
 
   cls = Class::New<ContextScope>();
   context_scope_class_ = cls.raw();
 
   cls = Class::New<ApiError>();
   api_error_class_ = cls.raw();
 
+  cls = Class::New<LanguageError>();
+  language_error_class_ = cls.raw();
+
+  cls = Class::New<UnhandledException>();
+  unhandled_exception_class_ = cls.raw();
+
+  cls = Class::New<UnwindError>();
+  unwind_error_class_ = cls.raw();
+
   ASSERT(class_class() != null_);
 }
 
 
 RawClass* Object::CreateAndRegisterInterface(const char* cname,
                                              const Script& script,
                                              const Library& lib) {
   const String& name = String::Handle(String::NewSymbol(cname));
   const Class& cls = Class::Handle(Class::NewInterface(name, script));
   lib.AddClass(cls);
@@ skipping 130 matching lines @@
   cls = Class::New<ExternalTwoByteString>();
   object_store->set_external_two_byte_string_class(cls);
   RegisterClass(cls, "ExternalTwoByteString", impl_script, core_impl_lib);
   pending_classes.Add(&Class::ZoneHandle(cls.raw()));
 
   cls = Class::New<ExternalFourByteString>();
   object_store->set_external_four_byte_string_class(cls);
   RegisterClass(cls, "ExternalFourByteString", impl_script, core_impl_lib);
   pending_classes.Add(&Class::ZoneHandle(cls.raw()));
 
-  cls = Class::New<UnhandledException>();
-  object_store->set_unhandled_exception_class(cls);
-  RegisterClass(cls, "UnhandledException", impl_script, core_impl_lib);
-  pending_classes.Add(&Class::ZoneHandle(cls.raw()));
-
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
   RegisterClass(cls, "Stacktrace", impl_script, core_impl_lib);
   pending_classes.Add(&Class::ZoneHandle(cls.raw()));
   // Super type set below, after Object is allocated.
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
   RegisterClass(cls, "JSSyntaxRegExp", impl_script, core_impl_lib);
   pending_classes.Add(&Class::ZoneHandle(cls.raw()));
@@ skipping 162 matching lines @@
 
   cls = Class::New<ExternalTwoByteString>();
   object_store->set_external_two_byte_string_class(cls);
 
   cls = Class::New<ExternalFourByteString>();
   object_store->set_external_four_byte_string_class(cls);
 
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
 
-  cls = Class::New<UnhandledException>();
-  object_store->set_unhandled_exception_class(cls);
-
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
 
   // Allocate pre-initialized values.
   Bool& bool_value = Bool::Handle();
   bool_value = Bool::New(true);
   object_store->set_true_value(bool_value);
@@ skipping 461 matching lines @@
   const Array& new_canonical_types = Array::Handle(Array::New(1, Heap::kOld));
   new_canonical_types.SetAt(0, signature_type);
   result.set_canonical_types(new_canonical_types);
   return result.raw();
 }
 
 
 RawClass* Class::GetClass(ObjectKind kind) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   switch (kind) {
-    case kUnhandledException:
-      ASSERT(object_store->unhandled_exception_class() != Class::null());
-      return object_store->unhandled_exception_class();
     case kSmi:
       ASSERT(object_store->smi_class() != Class::null());
       return object_store->smi_class();
     case kMint:
       ASSERT(object_store->mint_class() != Class::null());
       return object_store->mint_class();
     case kBigint:
       ASSERT(object_store->bigint_class() != Class::null());
       return object_store->bigint_class();
     case kDouble:
@@ skipping 3835 matching lines @@
                                      intptr_t context_level) const {
   VariableDescAddr(scope_index)->context_level = Smi::New(context_level);
 }
 
 
 const char* ContextScope::ToCString() const {
   return "ContextScope";
 }
 
 
+const char* Error::ToCString() const {
+  // Error is an abstract class.  We should never reach here.
+  UNREACHABLE();
+  return "Error";
+}
+
+
+RawApiError* ApiError::New(const String& message, Heap::Space space) {
+  const Class& cls = Class::Handle(Object::api_error_class());
+  ApiError& result = ApiError::Handle();
+  {
+    RawObject* raw = Object::Allocate(cls,
+                                      ApiError::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_message(message);
+  return result.raw();
+}
+
+
+void ApiError::set_message(const String& message) const {
+  StorePointer(&raw_ptr()->message_, message.raw());
+}
+
+
+const char* ApiError::ToCString() const {
+  return "ApiError";
+}
+
+
+RawLanguageError* LanguageError::New(const String& message, Heap::Space space) {
+  const Class& cls = Class::Handle(Object::language_error_class());
+  LanguageError& result = LanguageError::Handle();
+  {
+    RawObject* raw = Object::Allocate(cls,
+                                      LanguageError::InstanceSize(),
+                                      space);
+    NoGCScope no_gc;
+    result ^= raw;
+  }
+  result.set_message(message);
+  return result.raw();
+}
+
+
+void LanguageError::set_message(const String& message) const {
+  StorePointer(&raw_ptr()->message_, message.raw());
+}
+
+
+const char* LanguageError::ToCString() const {
+  return "LanguageError";
+}
+
+
 RawUnhandledException* UnhandledException::New(const Instance& exception,
                                                const Instance& stacktrace,
                                                Heap::Space space) {
-  Isolate* isolate = Isolate::Current();
-  const Class& cls = Class::Handle(
-      isolate->object_store()->unhandled_exception_class());
+  const Class& cls = Class::Handle(Object::unhandled_exception_class());
   UnhandledException& result = UnhandledException::Handle();
   {
     RawObject* raw = Object::Allocate(cls,
                                       UnhandledException::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_exception(exception);
   result.set_stacktrace(stacktrace);
   return result.raw();
 }
 
 
 void UnhandledException::set_exception(const Instance& exception) const {
   StorePointer(&raw_ptr()->exception_, exception.raw());
 }
 
 
 void UnhandledException::set_stacktrace(const Instance& stacktrace) const {
   StorePointer(&raw_ptr()->stacktrace_, stacktrace.raw());
 }
 
 
 const char* UnhandledException::ToCString() const {
   return "UnhandledException";
 }
 
 
-RawApiError* ApiError::New(const String& message, Heap::Space space) {
-  const Class& cls = Class::Handle(Object::api_error_class());
-  ApiError& result = ApiError::Handle();
+RawUnwindError* UnwindError::New(const String& message, Heap::Space space) {
+  const Class& cls = Class::Handle(Object::unwind_error_class());
+  UnwindError& result = UnwindError::Handle();
   {
     RawObject* raw = Object::Allocate(cls,
-                                      ApiError::InstanceSize(),
+                                      UnwindError::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
-  result.set_data(message);
+  result.set_message(message);
   return result.raw();
 }
 
 
-RawApiError* ApiError::New(const UnhandledException& exception,
-                           Heap::Space space) {
-  const Class& cls = Class::Handle(Object::api_error_class());
-  ApiError& result = ApiError::Handle();
-  {
-    RawObject* raw = Object::Allocate(cls,
-                                      ApiError::InstanceSize(),
-                                      space);
-    NoGCScope no_gc;
-    result ^= raw;
-  }
-  result.set_data(exception);
-  return result.raw();
+void UnwindError::set_message(const String& message) const {
+  StorePointer(&raw_ptr()->message_, message.raw());
 }
 
 
-void ApiError::set_data(const Object& data) const {
-  StorePointer(&raw_ptr()->data_, data.raw());
-}
-
-
-const char* ApiError::ToCString() const {
-  return "ApiError";
+const char* UnwindError::ToCString() const {
+  return "UnwindError";
 }
 
 
 bool Instance::Equals(const Instance& other) const {
   if (this->raw() == other.raw()) {
     return true;  // "===".
   }
 
   if (other.IsNull() || (this->clazz() != other.clazz())) {
     return false;
@@ skipping 2393 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