Standardize error printing a bit by moving it to the Error object and

runtime/lib/isolate.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/bootstrap_natives.h"
 
 #include "vm/assert.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
@@ skipping 35 matching lines @@
 
 static uint8_t* SerializeObject(const Instance& obj) {
   uint8_t* result = NULL;
   SnapshotWriter writer(Snapshot::kMessage, &result, &allocator);
   writer.WriteObject(obj.raw());
   writer.FinalizeBuffer();
   return result;
 }
 
 
-static void ProcessUnhandledException(const UnhandledException& uhe) {
-  const Instance& exception = Instance::Handle(uhe.exception());
-  Instance& string = Instance::Handle(DartLibraryCalls::ToString(exception));
-  const char* str = string.ToCString();
-  fprintf(stderr, "%s\n", str);
-  const Instance& stack = Instance::Handle(uhe.stacktrace());
-  string = DartLibraryCalls::ToString(stack);
-  str = string.ToCString();
-  fprintf(stderr, "%s\n", str);
+static void ProcessError(const Object& obj) {
+  ASSERT(obj.IsError());
+  Error& error = Error::Handle();
+  error ^= obj.raw();
+  fprintf(stderr, "%s\n", error.ToErrorCString());

[cshapiro, 2012/01/12 00:37:39]

Why not use OS::PrintErr instead of fprintf?

[turnidge, 2012/01/12 19:15:39]

Done.

   exit(255);
 }
 
 
 static void ThrowErrorException(Exceptions::ExceptionType type,
                                 const char* error_msg,
                                 const char* library_url,
                                 const char* class_name) {
   String& str = String::Handle();
   String& name = String::Handle();
@@ skipping 21 matching lines @@
       Resolver::ResolveStatic(Library::Handle(Library::CoreLibrary()),
                               class_name,
                               function_name,
                               kNumArguments,
                               kNoArgumentNames,
                               Resolver::kIsQualified));
   GrowableArray<const Object*> arguments(kNumArguments);
   arguments.Add(&Integer::Handle(Integer::New(port_id)));
   const Instance& result = Instance::Handle(
       DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
-  if (result.IsUnhandledException()) {
-    UnhandledException& uhe = UnhandledException::Handle();
-    uhe ^= result.raw();
-    ProcessUnhandledException(uhe);
+  if (result.IsError()) {
+    ProcessError(result);
   } else {
     PortMap::SetLive(port_id);
   }
   return result.raw();
 }
 
 
 static RawInstance* SendPortCreate(intptr_t port_id) {
   const String& class_name = String::Handle(String::NewSymbol("SendPortImpl"));
   const String& function_name = String::Handle(String::NewSymbol("_create"));
@@ skipping 51 matching lines @@
     const Function& default_constructor =
         Function::Handle(target_class.LookupConstructor(constructor_name));
     if (!default_constructor.IsNull()) {
       GrowableArray<const Object*> arguments(1);
       arguments.Add(&target);
       arguments.Add(&Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
       const Array& kNoArgumentNames = Array::Handle();
       result = DartEntry::InvokeStatic(default_constructor,
                                        arguments,
                                        kNoArgumentNames);
-      if (result.IsUnhandledException()) {
-        UnhandledException& uhe = UnhandledException::Handle();
-        uhe ^= result.raw();
-        ProcessUnhandledException(uhe);
+      if (result.IsError()) {
+        ProcessError(result);
       }
       ASSERT(result.IsNull());
     }
 
     // Invoke the "_run" method.
     const Function& target_function = Function::Handle(Resolver::ResolveDynamic(
         target, String::Handle(String::NewSymbol("_run")), 2, 0));
     // TODO(iposva): Proper error checking here.
     ASSERT(!target_function.IsNull());
     // TODO(iposva): Allocate the proper port number here.
     const Instance& local_port = Instance::Handle(ReceivePortCreate(port_id));
     GrowableArray<const Object*> arguments(1);
     arguments.Add(&local_port);
     const Array& kNoArgumentNames = Array::Handle();
     result = DartEntry::InvokeDynamic(target,
                                       target_function,
                                       arguments,
                                       kNoArgumentNames);
-    if (result.IsUnhandledException()) {
-      UnhandledException& uhe = UnhandledException::Handle();
-      uhe ^= result.raw();
-      ProcessUnhandledException(uhe);
+    if (result.IsError()) {
+      ProcessError(result);
     }
     ASSERT(result.IsNull());
     free(class_name);
     result = isolate->StandardRunLoop();
-    if (result.IsUnhandledException()) {
-      UnhandledException& uhe = UnhandledException::Handle();
-      uhe ^= result.raw();
-      ProcessUnhandledException(uhe);
+    if (result.IsError()) {
+      ProcessError(result);
     }
     ASSERT(result.IsNull());
 
   } else {
     Zone zone(isolate);
     HandleScope handle_scope(isolate);
     const String& error = String::Handle(
         Isolate::Current()->object_store()->sticky_error());
     const char* errmsg = error.ToCString();
     fprintf(stderr, "%s\n", errmsg);
@@ skipping 85 matching lines @@
   // Switch back to the original isolate and return.
   Isolate::SetCurrent(preserved_isolate);
   if (spawned_isolate == NULL) {
     // Unable to spawn isolate correctly, throw exception.
     ThrowErrorException(Exceptions::kIllegalArgument,
                         error,
                         library_url,
                         class_name);
   }
   const Instance& port = Instance::Handle(SendPortCreate(port_id));
-  if (port.IsUnhandledException()) {
-    ThrowErrorException(Exceptions::kInternalError,
-                        "Unable to create send port to isolate",
-                        library_url,
-                        class_name);
+  if (port.IsError()) {
+    if (port.IsUnhandledException()) {
+      ThrowErrorException(Exceptions::kInternalError,
+                          "Unable to create send port to isolate",
+                          library_url,
+                          class_name);
+    } else {
+      ProcessError(port);
+    }
   }
   arguments->SetReturn(port);
 }
 
 
 DEFINE_NATIVE_ENTRY(ReceivePortImpl_factory, 1) {
   ASSERT(AbstractTypeArguments::CheckedHandle(arguments->At(0)).IsNull());
   intptr_t port_id = PortMap::CreatePort();
   const Instance& port = Instance::Handle(ReceivePortCreate(port_id));
   arguments->SetReturn(port);
@@ skipping 10 matching lines @@
   intptr_t send_id = Smi::CheckedHandle(arguments->At(0)).Value();
   intptr_t reply_id = Smi::CheckedHandle(arguments->At(1)).Value();
   // TODO(iposva): Allow for arbitrary messages to be sent.
   uint8_t* data = SerializeObject(Instance::CheckedHandle(arguments->At(2)));
 
   // TODO(turnidge): Throw an exception when the return value is false?
   PortMap::PostMessage(send_id, reply_id, Api::CastMessage(data));
 }
 
 }  // namespace dart