Changed the message reporting for try { ... } finally { ... } statements to...

src/messages.cc

 
 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
@@ skipping 78 matching lines @@
     ? Factory::undefined_value()
     : Handle<Object>::cast(stack_trace);
   const int argc = 6;
   Object** argv[argc] = { type_str.location(),
                           array.location(),
                           start_handle.location(),
                           end_handle.location(),
                           script.location(),
                           stack_trace_val.location() };
 
+  // Setup a catch handler to catch exceptions in creating the message. This
+  // handler is non-verbose to avoid calling MakeMessage recursively in case of
+  // an exception.
+  v8::TryCatch catcher;
+  catcher.SetVerbose(false);
+  catcher.SetCaptureMessage(false);
+
+  // Format the message.
   bool caught_exception = false;
   Handle<Object> message =
-      Execution::TryCall(fun, Factory::undefined_value(), argc, argv,
-                         &caught_exception);
-  // If creating the message (in JS code) resulted in an exception, we
-  // skip doing the callback. This usually only happens in case of
-  // stack overflow exceptions being thrown by the parser when the
-  // stack is almost full.
-  if (caught_exception) return Handle<Object>();
+      Execution::Call(fun, Factory::undefined_value(), argc, argv,
+                      &caught_exception);
+  if (caught_exception) {
+    // If creating the message (in JS code) resulted in an exception, we
+    // skip doing the callback. This usually only happens in case of
+    // stack overflow exceptions being thrown by the parser when the
+    // stack is almost full.
+    if (caught_exception) return Handle<Object>();
+  }
+
   return message.EscapeFrom(&scope);
 }
 
 
 void MessageHandler::ReportMessage(MessageLocation* loc,
                                    Handle<Object> message) {
   v8::Local<v8::Message> api_message_obj = v8::Utils::MessageToLocal(message);
 
   v8::NeanderArray global_listeners(Factory::message_listeners());
   int global_length = global_listeners.length();
@@ skipping 41 matching lines @@
 }
 
 
 SmartPointer<char> MessageHandler::GetLocalizedMessage(Handle<Object> data) {
   HandleScope scope;
   return GetMessage(data)->ToCString(DISALLOW_NULLS);
 }
 
 
 } }  // namespace v8::internal