v8::TryCatch Class Reference

An external exception handler. More...

#include <v8.h>

Collaboration diagram for v8::TryCatch:

Public Member Functions
	TryCatch ()
	Creates a new try/catch block and registers it with v8. More...
	~TryCatch ()
	Unregisters and deletes this try/catch block. More...
bool	HasCaught () const
	Returns true if an exception has been caught by this try/catch block. More...
bool	CanContinue () const
	For certain types of exceptions, it makes no sense to continue execution. More...
bool	HasTerminated () const
	Returns true if an exception has been caught due to script execution being terminated. More...
Handle< Value >	ReThrow ()
	Throws the exception caught by this TryCatch in a way that avoids it being caught again by this same TryCatch. More...
Local< Value >	Exception () const
	Returns the exception caught by this try/catch block. More...
Local< Value >	StackTrace () const
	Returns the .stack property of the thrown object. More...
Local< v8::Message >	Message () const
	Returns the message associated with this exception. More...
void	Reset ()
	Clears any exceptions that may have been caught by this try/catch block. More...
void	SetVerbose (bool value)
	Set verbosity of the external exception handler. More...
void	SetCaptureMessage (bool value)
	Set whether or not this TryCatch should capture a Message object which holds source information about where the exception occurred. More...

Static Public Member Functions
static void *	JSStackComparableAddress (v8::TryCatch *handler)
	There are cases when the raw address of C++ TryCatch object cannot be used for comparisons with addresses into the JS stack. More...

Private Member Functions
void	ResetInternal ()
	TryCatch (const TryCatch &)
void	operator= (const TryCatch &)
void *	operator new (size_t size)
void	operator delete (void *, size_t)

Private Attributes
v8::internal::Isolate *	isolate_
v8::TryCatch *	next_
void *	exception_
void *	message_obj_
void *	message_script_
void *	js_stack_comparable_address_
int	message_start_pos_
int	message_end_pos_
bool	is_verbose_: 1
bool	can_continue_: 1
bool	capture_message_: 1
bool	rethrow_: 1
bool	has_terminated_: 1

Friends
class	v8::internal::Isolate

Detailed Description

An external exception handler.

Definition at line 5271 of file v8.h.

Constructor & Destructor Documentation

TryCatch() [1/2]

v8::TryCatch::TryCatch

(

)

Creates a new try/catch block and registers it with v8.

Note that all TryCatch blocks should be stack allocated because the memory location itself is compared against JavaScript try/catch blocks.

Definition at line 1906 of file api.cc.

    : isolate_(i::Isolate::Current()),
      next_(isolate_->try_catch_handler()),
      is_verbose_(false),
      can_continue_(true),
      capture_message_(true),
      rethrow_(false),
      has_terminated_(false) {
  ResetInternal();
  // Special handling for simulators which have a separate JS stack.
  js_stack_comparable_address_ =
      reinterpret_cast<void*>(v8::internal::SimulatorStack::RegisterCTryCatch(
          v8::internal::GetCurrentStackPosition()));
  isolate_->RegisterTryCatchHandler(this);
}

References v8::internal::GetCurrentStackPosition(), isolate_, js_stack_comparable_address_, v8::internal::SimulatorStack::RegisterCTryCatch(), v8::internal::Isolate::RegisterTryCatchHandler(), and ResetInternal().

Here is the call graph for this function:

~TryCatch()

v8::TryCatch::~TryCatch

(

)

Unregisters and deletes this try/catch block.

Definition at line 1923 of file api.cc.

                      {
  DCHECK(isolate_ == i::Isolate::Current());
  if (rethrow_) {
    v8::Isolate* isolate = reinterpret_cast<Isolate*>(isolate_);
    v8::HandleScope scope(isolate);
    v8::Local<v8::Value> exc = v8::Local<v8::Value>::New(isolate, Exception());
    if (HasCaught() && capture_message_) {
      // If an exception was caught and rethrow_ is indicated, the saved
      // message, script, and location need to be restored to Isolate TLS
      // for reuse.  capture_message_ needs to be disabled so that DoThrow()
      // does not create a new message.
      isolate_->thread_local_top()->rethrowing_message_ = true;
      isolate_->RestorePendingMessageFromTryCatch(this);
    }
    isolate_->UnregisterTryCatchHandler(this);
    v8::internal::SimulatorStack::UnregisterCTryCatch();
    reinterpret_cast<Isolate*>(isolate_)->ThrowException(exc);
    DCHECK(!isolate_->thread_local_top()->rethrowing_message_);
  } else {
    if (HasCaught() && isolate_->has_scheduled_exception()) {
      // If an exception was caught but is still scheduled because no API call
      // promoted it, then it is canceled to prevent it from being propagated.
      // Note that this will not cancel termination exceptions.
      isolate_->CancelScheduledExceptionFromTryCatch(this);
    }
    isolate_->UnregisterTryCatchHandler(this);
    v8::internal::SimulatorStack::UnregisterCTryCatch();
  }
}

References DCHECK, v8::Exception, v8::Local< T >::New(), and v8::internal::SimulatorStack::UnregisterCTryCatch().

Here is the call graph for this function:

TryCatch() [2/2]

v8::TryCatch::TryCatch ( const TryCatch &  )

private

Member Function Documentation

CanContinue()

bool v8::TryCatch::CanContinue

(

)

const

For certain types of exceptions, it makes no sense to continue execution.

If CanContinue returns false, the correct action is to perform any C++ cleanup needed and then return. If CanContinue returns false and HasTerminated returns true, it is possible to call CancelTerminateExecution in order to continue calling into the engine.

Definition at line 1959 of file api.cc.

                                   {
  return can_continue_;
}

Exception()

v8::Local< Value > v8::TryCatch::Exception

(

)

const

Returns the exception caught by this try/catch block.

If no exception has been caught an empty handle is returned.

The returned handle is valid until this TryCatch block has been destroyed.

Definition at line 1976 of file api.cc.

                                           {
  DCHECK(isolate_ == i::Isolate::Current());
  if (HasCaught()) {
    // Check for out of memory exception.
    i::Object* exception = reinterpret_cast<i::Object*>(exception_);
    return v8::Utils::ToLocal(i::Handle<i::Object>(exception, isolate_));
  } else {
    return v8::Local<Value>();
  }
}

References DCHECK, and v8::Utils::ToLocal().

Referenced by v8::Shell::ReportException().

Here is the call graph for this function:

Here is the caller graph for this function:

HasCaught()

bool v8::TryCatch::HasCaught

(

)

const

Returns true if an exception has been caught by this try/catch block.

Definition at line 1954 of file api.cc.

                                 {
  return !reinterpret_cast<i::Object*>(exception_)->IsTheHole();
}

Referenced by v8::Shell::ExecuteString(), v8::HandleDebugEvent(), main(), and v8::Shell::Write().

Here is the caller graph for this function:

HasTerminated()

bool v8::TryCatch::HasTerminated

(

)

const

Returns true if an exception has been caught due to script execution being terminated.

There is no JavaScript representation of an execution termination exception. Such exceptions are thrown when the TerminateExecution methods are called to terminate a long-running script.

If such an exception has been thrown, HasTerminated will return true, indicating that it is possible to call CancelTerminateExecution in order to continue calling into the engine.

Definition at line 1964 of file api.cc.

                                     {
  return has_terminated_;
}

JSStackComparableAddress()

static void* v8::TryCatch::JSStackComparableAddress ( v8::TryCatch *  handler )

inlinestatic

There are cases when the raw address of C++ TryCatch object cannot be used for comparisons with addresses into the JS stack.

The cases are: 1) ARM, ARM64 and MIPS simulators which have separate JS stack. 2) Address sanitizer allocates local C++ object in the heap when UseAfterReturn mode is enabled. This method returns address that can be used for comparisons with addresses into the JS stack. When neither simulator nor ASAN's UseAfterReturn is enabled, then the address returned will be the address of the C++ try catch handler itself.

Definition at line 5386 of file v8.h.

                                                             {
    if (handler == NULL) return NULL;
    return handler->js_stack_comparable_address_;
  }

References js_stack_comparable_address_, and NULL.

Referenced by v8::internal::BASE_EMBEDDED< Visitor >::try_catch_handler_address().

Here is the caller graph for this function:

Message()

v8::Local< v8::Message > v8::TryCatch::Message

(

)

const

Returns the message associated with this exception.

If there is no message associated an empty handle is returned.

The returned handle is valid until this TryCatch block has been destroyed.

Definition at line 2012 of file api.cc.

                                             {
  DCHECK(isolate_ == i::Isolate::Current());
  i::Object* message = reinterpret_cast<i::Object*>(message_obj_);
  DCHECK(message->IsJSMessageObject() || message->IsTheHole());
  if (HasCaught() && !message->IsTheHole()) {
    return v8::Utils::MessageToLocal(i::Handle<i::Object>(message, isolate_));
  } else {
    return v8::Local<v8::Message>();
  }
}

References DCHECK, and v8::Utils::MessageToLocal().

Referenced by main(), and v8::Shell::ReportException().

Here is the call graph for this function:

Here is the caller graph for this function:

operator delete()

void v8::TryCatch::operator delete ( void *  , size_t    )

private

operator new()

void* v8::TryCatch::operator new ( size_t  size )

private

operator=()

void v8::TryCatch::operator= ( const TryCatch &  )

private

Reset()

void v8::TryCatch::Reset

(

)

Clears any exceptions that may have been caught by this try/catch block.

After this method has been called, HasCaught() will return false. Cancels the scheduled exception if it is caught and ReThrow() is not called before.

It is not necessary to clear a try/catch block before using it again; if another exception is thrown the previously caught exception will just be overwritten. However, it is often a good idea since it makes it easier to determine which operation threw a given exception.

Definition at line 2024 of file api.cc.

                       {
  DCHECK(isolate_ == i::Isolate::Current());
  if (!rethrow_ && HasCaught() && isolate_->has_scheduled_exception()) {
    // If an exception was caught but is still scheduled because no API call
    // promoted it, then it is canceled to prevent it from being propagated.
    // Note that this will not cancel termination exceptions.
    isolate_->CancelScheduledExceptionFromTryCatch(this);
  }
  ResetInternal();
}

References DCHECK.

ResetInternal()

void v8::TryCatch::ResetInternal ( )

private

Definition at line 2036 of file api.cc.

                               {
  i::Object* the_hole = isolate_->heap()->the_hole_value();
  exception_ = the_hole;
  message_obj_ = the_hole;
  message_script_ = the_hole;
  message_start_pos_ = 0;
  message_end_pos_ = 0;
}

Referenced by TryCatch().

Here is the caller graph for this function:

ReThrow()

v8::Handle< v8::Value > v8::TryCatch::ReThrow

(

)

Throws the exception caught by this TryCatch in a way that avoids it being caught again by this same TryCatch.

As with ThrowException it is illegal to execute any JavaScript operations after calling ReThrow; the caller must return immediately to where the exception is caught.

Definition at line 1969 of file api.cc.

                                      {
  if (!HasCaught()) return v8::Local<v8::Value>();
  rethrow_ = true;
  return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate_));
}

References v8::Undefined().

Referenced by v8::Shell::Write().

Here is the call graph for this function:

Here is the caller graph for this function:

SetCaptureMessage()

void v8::TryCatch::SetCaptureMessage

(

bool

value

)

Set whether or not this TryCatch should capture a Message object which holds source information about where the exception occurred.

True by default.

Definition at line 2051 of file api.cc.

                                             {
  capture_message_ = value;
}

SetVerbose()

void v8::TryCatch::SetVerbose

(

bool

value

)

Set verbosity of the external exception handler.

By default, exceptions that are caught by an external exception handler are not reported. Call SetVerbose with true on an external exception handler to have exceptions caught by the handler reported as if they were not caught.

Definition at line 2046 of file api.cc.

                                      {
  is_verbose_ = value;
}

Referenced by v8::Shell::ExecuteString(), and v8::internal::LiveEdit::GatherCompileInfo().

Here is the caller graph for this function:

StackTrace()

v8::Local< Value > v8::TryCatch::StackTrace

(

)

const

Returns the .stack property of the thrown object.

If no .stack property is present an empty handle is returned.

Definition at line 1988 of file api.cc.

                                            {
  DCHECK(isolate_ == i::Isolate::Current());
  if (HasCaught()) {
    i::Object* raw_obj = reinterpret_cast<i::Object*>(exception_);
    if (!raw_obj->IsJSObject()) return v8::Local<Value>();
    i::HandleScope scope(isolate_);
    i::Handle<i::JSObject> obj(i::JSObject::cast(raw_obj), isolate_);
    i::Handle<i::String> name = isolate_->factory()->stack_string();
    EXCEPTION_PREAMBLE(isolate_);
    Maybe<bool> maybe = i::JSReceiver::HasProperty(obj, name);
    has_pending_exception = !maybe.has_value;
    EXCEPTION_BAILOUT_CHECK(isolate_, v8::Local<Value>());
    if (!maybe.value) return v8::Local<Value>();
    i::Handle<i::Object> value;
    if (!i::Object::GetProperty(obj, name).ToHandle(&value)) {
      return v8::Local<Value>();
    }
    return v8::Utils::ToLocal(scope.CloseAndEscape(value));
  } else {
    return v8::Local<Value>();
  }
}

References v8::internal::HandleScope::CloseAndEscape(), DCHECK, EXCEPTION_BAILOUT_CHECK, EXCEPTION_PREAMBLE, v8::internal::Object::GetProperty(), v8::internal::JSReceiver::HasProperty(), v8::maybe(), name, and v8::Utils::ToLocal().

Referenced by v8::Shell::ReportException().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

v8::internal::Isolate

friend class v8::internal::Isolate

friend

Definition at line 5414 of file v8.h.

Member Data Documentation

can_continue_

bool v8::TryCatch::can_continue_

private

Definition at line 5409 of file v8.h.

Referenced by v8::internal::Isolate::PropagatePendingExceptionToExternalTryCatch().

capture_message_

bool v8::TryCatch::capture_message_

private

Definition at line 5410 of file v8.h.

Referenced by v8::internal::Isolate::DoThrow().

exception_

void* v8::TryCatch::exception_

private

Definition at line 5402 of file v8.h.

Referenced by v8::internal::Isolate::PropagatePendingExceptionToExternalTryCatch().

has_terminated_

bool v8::TryCatch::has_terminated_

private

Definition at line 5412 of file v8.h.

Referenced by v8::internal::Isolate::CancelTerminateExecution(), and v8::internal::Isolate::PropagatePendingExceptionToExternalTryCatch().

is_verbose_

bool v8::TryCatch::is_verbose_

private

Definition at line 5408 of file v8.h.

Referenced by v8::internal::Isolate::ShouldReportException().

isolate_

v8::internal::Isolate* v8::TryCatch::isolate_

private

Definition at line 5400 of file v8.h.

Referenced by TryCatch().

js_stack_comparable_address_

void* v8::TryCatch::js_stack_comparable_address_

private

Definition at line 5405 of file v8.h.

Referenced by JSStackComparableAddress(), and TryCatch().

message_end_pos_

int v8::TryCatch::message_end_pos_

private

Definition at line 5407 of file v8.h.

message_obj_

void* v8::TryCatch::message_obj_

private

Definition at line 5403 of file v8.h.

message_script_

void* v8::TryCatch::message_script_

private

Definition at line 5404 of file v8.h.

message_start_pos_

int v8::TryCatch::message_start_pos_

private

Definition at line 5406 of file v8.h.

next_

v8::TryCatch* v8::TryCatch::next_

private

Definition at line 5401 of file v8.h.

Referenced by v8::internal::Isolate::UnregisterTryCatchHandler().

rethrow_

bool v8::TryCatch::rethrow_

private

Definition at line 5411 of file v8.h.

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/include/v8.h
• /mnt/V8SourceCode/src/api.cc