Revert of Wrap v8natives.js into a function.

src/isolate.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/v8.h"
@@ skipping 891 matching lines @@
       entry = api_interrupts_queue_.front();
       api_interrupts_queue_.pop();
     }
     VMState<EXTERNAL> state(this);
     HandleScope handle_scope(this);
     entry.first(reinterpret_cast<v8::Isolate*>(this), entry.second);
   }
 }
 
 
-void Isolate::ReportBootstrappingException(Handle<Object> exception,
-                                           MessageLocation* location) {
+void ReportBootstrappingException(Handle<Object> exception,
+                                  MessageLocation* location) {
   base::OS::PrintError("Exception thrown during bootstrapping\n");
-  if (location == NULL || location->script().is_null()) {
-    exception->Print();
-    PrintStack(stdout);
-    return;
-  }
+  if (location == NULL || location->script().is_null()) return;
   // We are bootstrapping and caught an error where the location is set
   // and we have a script for the location.
   // In this case we could have an extension (or an internal error
   // somewhere) and we print out the line number at which the error occured
   // to the console for easier debugging.
   int line_number =
       location->script()->GetLineNumber(location->start_pos()) + 1;
   if (exception->IsString() && location->script()->name()->IsString()) {
     base::OS::PrintError(
         "Extension or internal compilation error: %s in %s at line %d.\n",
@@ skipping 48 matching lines @@
                           try_catch_handler()->capture_message_;
   bool rethrowing_message = thread_local_top()->rethrowing_message_;
 
   thread_local_top()->rethrowing_message_ = false;
 
   // Notify debugger of exception.
   if (is_catchable_by_javascript(exception)) {
     debug()->OnThrow(exception_handle);
   }
 
-  if (bootstrapper()->IsActive()) {
-    // It's not safe to try to make message objects or collect stack traces
-    // while the bootstrapper is active since the infrastructure may not have
-    // been properly initialized.
-    ReportBootstrappingException(exception_handle, location);
-  } else if (requires_message && !rethrowing_message) {
+  // Generate the message if required.
+  if (requires_message && !rethrowing_message) {
     MessageLocation potential_computed_location;
     if (location == NULL) {
       // If no location was specified we use a computed one instead.
       ComputeLocation(&potential_computed_location);
       location = &potential_computed_location;
     }
 
-    Handle<Object> message_obj = CreateMessage(exception_handle, location);
-    thread_local_top()->pending_message_obj_ = *message_obj;
+    if (bootstrapper()->IsActive()) {
+      // It's not safe to try to make message objects or collect stack traces
+      // while the bootstrapper is active since the infrastructure may not have
+      // been properly initialized.
+      ReportBootstrappingException(exception_handle, location);
+    } else {
+      Handle<Object> message_obj = CreateMessage(exception_handle, location);
+      thread_local_top()->pending_message_obj_ = *message_obj;
 
-    // If the abort-on-uncaught-exception flag is specified, abort on any
-    // exception not caught by JavaScript, even when an external handler is
-    // present.  This flag is intended for use by JavaScript developers, so
-    // print a user-friendly stack trace (not an internal one).
-    if (FLAG_abort_on_uncaught_exception &&
-        PredictExceptionCatcher() != CAUGHT_BY_JAVASCRIPT) {
-      FLAG_abort_on_uncaught_exception = false;  // Prevent endless recursion.
-      PrintF(stderr, "%s\n\nFROM\n",
-             MessageHandler::GetLocalizedMessage(this, message_obj).get());
-      PrintCurrentStackTrace(stderr);
-      base::OS::Abort();
+      // If the abort-on-uncaught-exception flag is specified, abort on any
+      // exception not caught by JavaScript, even when an external handler is
+      // present.  This flag is intended for use by JavaScript developers, so
+      // print a user-friendly stack trace (not an internal one).
+      if (FLAG_abort_on_uncaught_exception &&
+          PredictExceptionCatcher() != CAUGHT_BY_JAVASCRIPT) {
+        FLAG_abort_on_uncaught_exception = false;  // Prevent endless recursion.
+        PrintF(stderr, "%s\n\nFROM\n",
+               MessageHandler::GetLocalizedMessage(this, message_obj).get());
+        PrintCurrentStackTrace(stderr);
+        base::OS::Abort();
+      }
     }
   }
 
   // Set the exception being thrown.
   set_pending_exception(*exception_handle);
   return heap()->exception();
 }
 
 
 Object* Isolate::ReThrow(Object* exception) {
@@ skipping 1736 matching lines @@
   if (prev_ && prev_->Intercept(flag)) return true;
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 } }  // namespace v8::internal