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

src/top.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
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 576 matching lines @@
   Handle<Object> exception = Copy(boilerplate);
   // TODO(1240995): To avoid having to call JavaScript code to compute
   // the message for stack overflow exceptions which is very likely to
   // double fault with another stack overflow exception, we use a
   // precomputed message. This is somewhat problematic in that it
   // doesn't use ReportUncaughtException to determine the location
   // from where the exception occurred. It should probably be
   // reworked.
   static const char* kMessage =
       "Uncaught RangeError: Maximum call stack size exceeded";
-  DoThrow(*exception, NULL, kMessage, false);
+  DoThrow(*exception, NULL, kMessage);
   return Failure::Exception();
 }
 
 
 Failure* Top::Throw(Object* exception, MessageLocation* location) {
-  DoThrow(exception, location, NULL, false);
+  DoThrow(exception, location, NULL);
   return Failure::Exception();
 }
 
 
 Failure* Top::ReThrow(Object* exception, MessageLocation* location) {
-  DoThrow(exception, location, NULL, true);
+  // Check is this exception is externally caught.
+  bool is_caught_externally = false;
+  ShouldReportException(&is_caught_externally);
+  thread_local_.external_caught_exception_ = is_caught_externally;
+
+  // Set the exception beeing re-thrown.
+  set_pending_exception(exception);
   return Failure::Exception();
 }
 
 
 void Top::ScheduleThrow(Object* exception) {
   // When scheduling a throw we first throw the exception to get the
   // error reporting if it is uncaught before rescheduling it.
   Throw(exception);
   thread_local_.scheduled_exception_ = pending_exception();
   thread_local_.external_caught_exception_ = false;
@@ skipping 97 matching lines @@
   // address of the external handler so we can compare the address to
   // determine which one is closer to the top of the stack.
   bool has_external_handler = (thread_local_.try_catch_handler_ != NULL);
   Address external_handler_address =
       reinterpret_cast<Address>(thread_local_.try_catch_handler_);
 
   // NOTE: The stack is assumed to grown towards lower addresses. If
   // the handler is at a higher address than the external address it
   // means that it is below it on the stack.
 
-  // Find the top-most try-catch or try-finally handler.
-  while (handler != NULL && handler->is_entry()) {
-    handler = handler->next();
-  }
-
-  // The exception has been externally caught if and only if there is
-  // an external handler which is above any JavaScript try-catch or
-  // try-finally handlers.
-  *is_caught_externally = has_external_handler &&
-      (handler == NULL || handler->address() > external_handler_address);
-
   // Find the top-most try-catch handler.
   while (handler != NULL && !handler->is_try_catch()) {
     handler = handler->next();
   }
 
+  // The exception has been externally caught if and only if there is
+  // an external handler which is above any JavaScript try-catch but NOT
+  // try-finally handlers.
+  *is_caught_externally = has_external_handler &&
+      (handler == NULL || handler->address() > external_handler_address);
+
   // If we have a try-catch handler then the exception is caught in
   // JavaScript code.
   bool is_uncaught_by_js = (handler == NULL);
 
   // If there is no external try-catch handler, we report the
   // exception if it isn't caught by JavaScript code.
   if (!has_external_handler) return is_uncaught_by_js;
 
   if (is_uncaught_by_js || handler->address() > external_handler_address) {
     // Only report the exception if the external handler is verbose.
     return thread_local_.try_catch_handler_->is_verbose_;
   } else {
     // Report the exception if it isn't caught by JavaScript code.
     return is_uncaught_by_js;
   }
 }
 
 
 void Top::DoThrow(Object* exception,
                   MessageLocation* location,
-                  const char* message,
-                  bool is_rethrow) {
+                  const char* message) {
   ASSERT(!has_pending_exception());
-  ASSERT(!external_caught_exception());
 
   HandleScope scope;
   Handle<Object> exception_handle(exception);
 
+  // Determine reporting and whether the exception is caught externally.
   bool is_caught_externally = false;
   bool report_exception = (exception != Failure::OutOfMemoryException()) &&
-    ShouldReportException(&is_caught_externally);
-  if (is_rethrow) report_exception = false;
+      ShouldReportException(&is_caught_externally);
 
+  // Generate the message.
   Handle<Object> message_obj;
   MessageLocation potential_computed_location;
   bool try_catch_needs_message =
-    is_caught_externally && thread_local_.try_catch_handler_->capture_message_;
+      is_caught_externally &&
+      thread_local_.try_catch_handler_->capture_message_;
   if (report_exception || try_catch_needs_message) {
     if (location == NULL) {
       // If no location was specified we use a computed one instead
       ComputeLocation(&potential_computed_location);
       location = &potential_computed_location;
     }
     Handle<String> stack_trace;
     if (FLAG_trace_exception) stack_trace = StackTrace();
     message_obj = MessageHandler::MakeMessageObject("uncaught_exception",
         location, HandleVector<Object>(&exception_handle, 1), stack_trace);
@@ skipping 15 matching lines @@
   Debugger::OnException(exception_handle, report_exception);
 
   if (report_exception) {
     if (message != NULL) {
       MessageHandler::ReportMessage(message);
     } else {
       MessageHandler::ReportMessage(location, message_obj);
     }
   }
   thread_local_.external_caught_exception_ = is_caught_externally;
+
   // NOTE: Notifying the debugger or reporting the exception may have caused
   // new exceptions. For now, we just ignore that and set the pending exception
   // to the original one.
   set_pending_exception(*exception_handle);
 }
 
 
 void Top::TraceException(bool flag) {
   FLAG_trace_exception = flag;
 }
@@ skipping 69 matching lines @@
   Top::break_access_->Lock();
 }
 
 
 ExecutionAccess::~ExecutionAccess() {
   Top::break_access_->Unlock();
 }
 
 
 } }  // namespace v8::internal