Posponed the setting of "external_caught_exception" to when leaving JavaScrip...

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 83 matching lines @@
   thread_local_.c_entry_fp_ = 0;
   thread_local_.handler_ = 0;
   thread_local_.stack_is_cooked_ = false;
   thread_local_.try_catch_handler_ = NULL;
   thread_local_.context_ = NULL;
   thread_local_.external_caught_exception_ = false;
   thread_local_.failed_access_check_callback_ = NULL;
   clear_pending_exception();
   clear_scheduled_exception();
   thread_local_.save_context_ = NULL;
+  thread_local_.catcher_ = NULL;
 }
 
 
 // Create a dummy thread that will wait forever on a semaphore. The only
 // purpose for this thread is to have some stack area to save essential data
 // into for use by a stacks only core dump (aka minidump).
 class PreallocatedMemoryThread: public Thread {
  public:
   PreallocatedMemoryThread() : keep_running_(true) {
     wait_for_ever_semaphore_ = OS::CreateSemaphore(0);
@@ skipping 485 matching lines @@
 }
 
 
 Failure* Top::Throw(Object* exception, MessageLocation* location) {
   DoThrow(exception, location, NULL);
   return Failure::Exception();
 }
 
 
 Failure* Top::ReThrow(Object* exception, MessageLocation* location) {
-  // 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.

[Kasper Lund, 2008/10/23 12:52:43]

beeing sb. being

   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();
@@ skipping 161 matching lines @@
     }
     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);
   }
 
   // If the exception is caught externally, we store it in the
   // try/catch handler. The C code can find it later and process it if
   // necessary.
+  thread_local_.catcher_ = NULL;
   if (is_caught_externally) {
+    thread_local_.catcher_ = thread_local_.try_catch_handler_;
     thread_local_.try_catch_handler_->exception_ =
       reinterpret_cast<void*>(*exception_handle);
     if (!message_obj.is_null()) {
       thread_local_.try_catch_handler_->message_ =
         reinterpret_cast<void*>(*message_obj);
     }
   }
 
   // Notify debugger of exception.
   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 70 matching lines @@
   Top::break_access_->Lock();
 }
 
 
 ExecutionAccess::~ExecutionAccess() {
   Top::break_access_->Unlock();
 }
 
 
 } }  // namespace v8::internal