v8::Debug Class Reference

#include <v8-debug.h>

Collaboration diagram for v8::Debug:

Classes
class	ClientData
	A client object passed to the v8 debugger whose ownership will be taken by it. More...
class	EventDetails
	An event details object passed to the debug event listener. More...
class	Message
	A message object passed to the debug message handler. More...

Public Types
typedef void(*	EventCallback) (const EventDetails &event_details)
	Debug event callback function. More...
typedef void(*	MessageHandler) (const Message &message)
	Debug message callback function. More...
typedef void(*	DebugMessageDispatchHandler) ()
	Callback function for the host to ensure debug messages are processed. More...

Static Public Member Functions
static bool	SetDebugEventListener (EventCallback that, Handle< Value > data=Handle< Value >())
static void	DebugBreak (Isolate *isolate)
static void	CancelDebugBreak (Isolate *isolate)
static bool	CheckDebugBreak (Isolate *isolate)
static void	DebugBreakForCommand (Isolate *isolate, ClientData *data)
static void	SetMessageHandler (MessageHandler handler)
static void	SendCommand (Isolate *isolate, const uint16_t *command, int length, ClientData *client_data=NULL)
static Local< Value >	Call (v8::Handle< v8::Function > fun, Handle< Value > data=Handle< Value >())
	Run a JavaScript function in the debugger. More...
static Local< Value >	GetMirror (v8::Handle< v8::Value > obj)
	Returns a mirror object for the given object. More...
static void	ProcessDebugMessages ()
	Makes V8 process all pending debug messages. More...
static Local< Context >	GetDebugContext ()
	Debugger is running in its own context which is entered while debugger messages are being dispatched. More...
static void	SetLiveEditEnabled (Isolate *isolate, bool enable)
	Enable/disable LiveEdit functionality for the given Isolate (default Isolate if not provided). More...

Detailed Description

Definition at line 29 of file v8-debug.h.

Member Typedef Documentation

DebugMessageDispatchHandler

typedef void(* v8::Debug::DebugMessageDispatchHandler) ()

Callback function for the host to ensure debug messages are processed.

Definition at line 157 of file v8-debug.h.

EventCallback

typedef void(* v8::Debug::EventCallback) (const EventDetails &event_details)

Debug event callback function.

Parameters

event_details

object providing information about the debug event

A EventCallback2 does not take possession of the event data, and must not rely on the data persisting after the handler returns.

Definition at line 142 of file v8-debug.h.

MessageHandler

typedef void(* v8::Debug::MessageHandler) (const Message &message)

Debug message callback function.

Parameters

message

the debug message handler message object

A MessageHandler2 does not take possession of the message data, and must not rely on the data persisting after the handler returns.

Definition at line 152 of file v8-debug.h.

Member Function Documentation

Call()

Local< Value > v8::Debug::Call ( v8::Handle< v8::Function >  fun, Handle< Value >  data = Handle<Value>()  )

static

Run a JavaScript function in the debugger.

Parameters

fun

the function to call

data

passed as second argument to the function With this call the debugger is entered and the function specified is called with the execution state as the first argument. This makes it possible to get access to information otherwise not available during normal JavaScript execution e.g. details on stack frames. Receiver of the function call will be the debugger context global object, however this is a subject to change. The following example shows a JavaScript function which when passed to v8::Debug::Call will return the current line of JavaScript execution.

function frame_source_line(exec_state) {
  return exec_state.frame(0).sourceLine();
}

Definition at line 6972 of file api.cc.

                                                 {
  i::Isolate* isolate = i::Isolate::Current();
  if (!isolate->IsInitialized()) return Local<Value>();
  ON_BAILOUT(isolate, "v8::Debug::Call()", return Local<Value>());
  ENTER_V8(isolate);
  i::MaybeHandle<i::Object> maybe_result;
  EXCEPTION_PREAMBLE(isolate);
  if (data.IsEmpty()) {
    maybe_result = isolate->debug()->Call(
        Utils::OpenHandle(*fun), isolate->factory()->undefined_value());
  } else {
    maybe_result = isolate->debug()->Call(
        Utils::OpenHandle(*fun), Utils::OpenHandle(*data));
  }
  i::Handle<i::Object> result;
  has_pending_exception = !maybe_result.ToHandle(&result);
  EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>());
  return Utils::ToLocal(result);
}

References v8::internal::Debug::Call(), v8::internal::Isolate::debug(), ENTER_V8, EXCEPTION_BAILOUT_CHECK, EXCEPTION_PREAMBLE, v8::internal::Isolate::factory(), v8::Handle< T >::IsEmpty(), v8::internal::Isolate::IsInitialized(), ON_BAILOUT, v8::Utils::OpenHandle(), and v8::Utils::ToLocal().

Here is the call graph for this function:

CancelDebugBreak()

void v8::Debug::CancelDebugBreak ( Isolate *  isolate )

static

Definition at line 6937 of file api.cc.

                                             {
  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
  internal_isolate->stack_guard()->ClearDebugBreak();
}

References v8::internal::Isolate::stack_guard().

Here is the call graph for this function:

CheckDebugBreak()

bool v8::Debug::CheckDebugBreak ( Isolate *  isolate )

static

Definition at line 6943 of file api.cc.

                                            {
  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
  return internal_isolate->stack_guard()->CheckDebugBreak();
}

References v8::internal::Isolate::stack_guard().

Here is the call graph for this function:

DebugBreak()

void v8::Debug::DebugBreak ( Isolate *  isolate )

static

Definition at line 6932 of file api.cc.

                                       {
  reinterpret_cast<i::Isolate*>(isolate)->stack_guard()->RequestDebugBreak();
}

DebugBreakForCommand()

void v8::Debug::DebugBreakForCommand ( Isolate *  isolate, ClientData *  data  )

static

Definition at line 6949 of file api.cc.

                                                                   {
  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
  internal_isolate->debug()->EnqueueDebugCommand(data);
}

References v8::internal::Isolate::debug(), and v8::internal::Debug::EnqueueDebugCommand().

Here is the call graph for this function:

GetDebugContext()

Local< Context > v8::Debug::GetDebugContext ( )

static

Debugger is running in its own context which is entered while debugger messages are being dispatched.

This is an explicit getter for this debugger context. Note that the content of the debugger context is subject to change.

Definition at line 7028 of file api.cc.

                                      {
  i::Isolate* isolate = i::Isolate::Current();
  ENTER_V8(isolate);
  return Utils::ToLocal(i::Isolate::Current()->debug()->GetDebugContext());
}

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

Here is the call graph for this function:

GetMirror()

Local< Value > v8::Debug::GetMirror ( v8::Handle< v8::Value >  obj )

static

Returns a mirror object for the given object.

Definition at line 6994 of file api.cc.

                                                   {
  i::Isolate* isolate = i::Isolate::Current();
  if (!isolate->IsInitialized()) return Local<Value>();
  ON_BAILOUT(isolate, "v8::Debug::GetMirror()", return Local<Value>());
  ENTER_V8(isolate);
  v8::EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
  i::Debug* isolate_debug = isolate->debug();
  EXCEPTION_PREAMBLE(isolate);
  has_pending_exception = !isolate_debug->Load();
  v8::Local<v8::Value> result;
  if (!has_pending_exception) {
    i::Handle<i::JSObject> debug(
        isolate_debug->debug_context()->global_object());
    i::Handle<i::String> name = isolate->factory()->InternalizeOneByteString(
        STATIC_CHAR_VECTOR("MakeMirror"));
    i::Handle<i::Object> fun_obj =
        i::Object::GetProperty(debug, name).ToHandleChecked();
    i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>::cast(fun_obj);
    v8::Handle<v8::Function> v8_fun = Utils::ToLocal(fun);
    const int kArgc = 1;
    v8::Handle<v8::Value> argv[kArgc] = { obj };
    result = v8_fun->Call(Utils::ToLocal(debug), kArgc, argv);
    has_pending_exception = result.IsEmpty();
  }
  EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>());
  return scope.Escape(result);
}

References v8::internal::Handle< T >::cast(), v8::internal::Isolate::debug(), v8::internal::Debug::debug_context(), ENTER_V8, v8::EscapableHandleScope::Escape(), EXCEPTION_BAILOUT_CHECK, EXCEPTION_PREAMBLE, v8::internal::Isolate::factory(), v8::internal::Object::GetProperty(), v8::Handle< T >::IsEmpty(), v8::internal::Isolate::IsInitialized(), v8::internal::Debug::Load(), name, ON_BAILOUT, STATIC_CHAR_VECTOR, and v8::Utils::ToLocal().

Here is the call graph for this function:

ProcessDebugMessages()

void v8::Debug::ProcessDebugMessages ( )

static

Makes V8 process all pending debug messages.

From V8 point of view all debug messages come asynchronously (e.g. from remote debugger) but they all must be handled synchronously: V8 cannot do 2 things at one time so normal script execution must be interrupted for a while.

Generally when message arrives V8 may be in one of 3 states:

1. V8 is running script; V8 will automatically interrupt and process all pending messages;
2. V8 is suspended on debug breakpoint; in this state V8 is dedicated to reading and processing debug messages;
3. V8 is not running at all or has called some long-working C++ function; by default it means that processing of all debug messages will be deferred until V8 gets control again; however, embedding application may improve this by manually calling this method.

Technically this method in many senses is equivalent to executing empty script:

1. It does nothing except for processing all pending debug messages.
2. It should be invoked with the same precautions and from the same context as V8 script would be invoked from, because: a. with "evaluate" command it can do whatever normal script can do, including all native calls; b. no other thread should call V8 while this method is running (v8::Locker may be used here).

"Evaluate" debug command behavior currently is not specified in scope of this method.

Definition at line 7023 of file api.cc.

                                 {
  i::Isolate::Current()->debug()->ProcessDebugMessages(true);
}

SendCommand()

void v8::Debug::SendCommand ( Isolate *  isolate, const uint16_t *  command, int  length, ClientData *  client_data = NULL  )

static

Definition at line 6962 of file api.cc.

                                                 {
  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
  internal_isolate->debug()->EnqueueCommandMessage(
      i::Vector<const uint16_t>(command, length), client_data);
}

References v8::internal::Isolate::debug(), and v8::internal::Debug::EnqueueCommandMessage().

Here is the call graph for this function:

SetDebugEventListener()

bool v8::Debug::SetDebugEventListener ( EventCallback  that, Handle< Value >  data = Handle<Value>()  )

static

Definition at line 6917 of file api.cc.

                                                                        {
  i::Isolate* isolate = i::Isolate::Current();
  ON_BAILOUT(isolate, "v8::Debug::SetDebugEventListener()", return false);
  ENTER_V8(isolate);
  i::HandleScope scope(isolate);
  i::Handle<i::Object> foreign = isolate->factory()->undefined_value();
  if (that != NULL) {
    foreign = isolate->factory()->NewForeign(FUNCTION_ADDR(that));
  }
  isolate->debug()->SetEventListener(foreign,
                                     Utils::OpenHandle(*data, true));
  return true;
}

References v8::internal::Isolate::debug(), ENTER_V8, v8::internal::Isolate::factory(), FUNCTION_ADDR, NULL, ON_BAILOUT, v8::Utils::OpenHandle(), and v8::internal::Debug::SetEventListener().

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

Here is the call graph for this function:

Here is the caller graph for this function:

SetLiveEditEnabled()

void v8::Debug::SetLiveEditEnabled ( Isolate *  isolate, bool  enable  )

static

Enable/disable LiveEdit functionality for the given Isolate (default Isolate if not provided).

V8 will abort if LiveEdit is unexpectedly used. LiveEdit is enabled by default.

Definition at line 7035 of file api.cc.

                                                            {
  i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
  internal_isolate->debug()->set_live_edit_enabled(enable);
}

References v8::internal::Isolate::debug(), and v8::internal::Debug::set_live_edit_enabled().

Here is the call graph for this function:

SetMessageHandler()

void v8::Debug::SetMessageHandler ( MessageHandler  handler )

static

Definition at line 6955 of file api.cc.

                                                           {
  i::Isolate* isolate = i::Isolate::Current();
  ENTER_V8(isolate);
  isolate->debug()->SetMessageHandler(handler);
}

References v8::internal::Isolate::debug(), ENTER_V8, and v8::internal::Debug::SetMessageHandler().

Here is the call graph for this function:

---

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

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