Use the --debug command line flag to enable.
It appears that d8 sucks. Luckily it can be rewritten rather easily with the
repl and tcp client libraries.
Node's CL option parsing is getting rather unwieldy - needs refactor.
*/
typedef void (*HostDispatchHandler)();
+ /**
+ * Callback function for the host to ensure debug messages are processed.
+ */
+ typedef void (*DebugMessageDispatchHandler)();
+
// Set a C debug event listener.
static bool SetDebugEventListener(EventCallback that,
Handle<Value> data = Handle<Value>());
static void SetHostDispatchHandler(HostDispatchHandler handler,
int period = 100);
+ /**
+ * Register a callback function to be called when a debug message has been
+ * received and is ready to be precessed. For the debug messages to be
+ * processed V8 needs to be entered, and in certain embedding scenarios this
+ * callback can be used to make sure V8 is entered for the debug message to
+ * be processed. Note that debug messages will only be processed if there is
+ * a V8 break. This can happen automatically by using the option
+ * --debugger-auto-break.
+ */
+ static void SetDebugMessageDispatchHandler(
+ DebugMessageDispatchHandler handler);
+
/**
* Run a JavaScript function in the debugger.
* \param fun the function to call
}
+void Debug::SetDebugMessageDispatchHandler(
+ DebugMessageDispatchHandler handler) {
+ EnsureInitialized("v8::Debug::SetDebugMessageDispatchHandler");
+ ENTER_V8;
+ i::Debugger::SetDebugMessageDispatchHandler(handler);
+}
+
+
Local<Value> Debug::Call(v8::Handle<v8::Function> fun,
v8::Handle<v8::Value> data) {
if (!i::V8::IsRunning()) return Local<Value>();
v8::Debug::MessageHandler2 Debugger::message_handler_ = NULL;
bool Debugger::debugger_unload_pending_ = false;
v8::Debug::HostDispatchHandler Debugger::host_dispatch_handler_ = NULL;
+v8::Debug::DebugMessageDispatchHandler
+ Debugger::debug_message_dispatch_handler_ = NULL;
int Debugger::host_dispatch_micros_ = 100 * 1000;
DebuggerAgent* Debugger::agent_ = NULL;
LockingCommandMessageQueue Debugger::command_queue_(kQueueInitialSize);
}
+void Debugger::SetDebugMessageDispatchHandler(
+ v8::Debug::DebugMessageDispatchHandler handler) {
+ debug_message_dispatch_handler_ = handler;
+}
+
+
// Calls the registered debug message handler. This callback is part of the
// public API.
void Debugger::InvokeMessageHandler(MessageImpl message) {
if (!Debug::InDebugger()) {
StackGuard::DebugCommand();
}
+
+ if (Debugger::debug_message_dispatch_handler_ != NULL) {
+ Debugger::debug_message_dispatch_handler_();
+ }
}
static void SetMessageHandler(v8::Debug::MessageHandler2 handler);
static void SetHostDispatchHandler(v8::Debug::HostDispatchHandler handler,
int period);
+ static void SetDebugMessageDispatchHandler(
+ v8::Debug::DebugMessageDispatchHandler handler);
// Invoke the message handler function.
static void InvokeMessageHandler(MessageImpl message);
static v8::Debug::MessageHandler2 message_handler_;
static bool debugger_unload_pending_; // Was message handler cleared?
static v8::Debug::HostDispatchHandler host_dispatch_handler_;
+ static v8::Debug::DebugMessageDispatchHandler debug_message_dispatch_handler_;
static int host_dispatch_micros_;
static DebuggerAgent* agent_;
namespace node {
static int dash_dash_index = 0;
+static bool use_debug_agent = false;
enum encoding ParseEncoding(Handle<Value> encoding_v, enum encoding _default) {
HandleScope scope;
ev_async_send(EV_DEFAULT_UC_ &eio_watcher);
}
+static ev_async debug_watcher;
+
+static void DebugMessageCallback(EV_P_ ev_async *watcher, int revents) {
+ HandleScope scope;
+ assert(watcher == &debug_watcher);
+ assert(revents == EV_ASYNC);
+ ExecuteString(String::New("1+1;"),
+ String::New("debug_poll"));
+}
+
+static void DebugMessageDispatch(void) {
+ ev_async_send(EV_DEFAULT_UC_ &debug_watcher);
+}
+
+
static void ExecuteNativeJS(const char *filename, const char *data) {
HandleScope scope;
TryCatch try_catch;
static void PrintHelp() {
printf("Usage: node [options] [--] script.js [arguments] \n"
" -v, --version print node's version\n"
+ " --debug enable remote debugging\n" // TODO specify port
" --cflags print pre-processor and compiler flags\n"
" --v8-options print v8 command line options\n\n"
"Documentation can be found at http://tinyclouds.org/node/api.html"
}
static void ParseArgs(int *argc, char **argv) {
+ // TODO use parse opts
for (int i = 1; i < *argc; i++) {
const char *arg = argv[i];
if (strcmp(arg, "--") == 0) {
dash_dash_index = i;
break;
+ } else if (strcmp(arg, "--debug") == 0) {
+ argv[i] = reinterpret_cast<const char*>("");
+ use_debug_agent = true;
+ dash_dash_index = i;
} else if (strcmp(arg, "--version") == 0 || strcmp(arg, "-v") == 0) {
printf("%s\n", NODE_VERSION);
exit(0);
HandleScope handle_scope;
+#define AUTO_BREAK_FLAG "--debugger_auto_break"
+ if (node::use_debug_agent) {
+ V8::SetFlagsFromString(AUTO_BREAK_FLAG, sizeof(AUTO_BREAK_FLAG));
+ ev_async_init(&node::debug_watcher, node::DebugMessageCallback);
+ Debug::SetDebugMessageDispatchHandler(node::DebugMessageDispatch);
+ ev_async_start(EV_DEFAULT_UC_ &node::debug_watcher);
+ ev_unref(EV_DEFAULT_UC);
+
+ bool r = Debug::EnableAgent("node " NODE_VERSION, 5858);
+ assert(r);
+ printf("debugger listening on port 5858\n"
+ "Use 'd8 --remote_debugger' to access it.\n");
+ }
+
Local<FunctionTemplate> process_template = FunctionTemplate::New();
// The global object / "process" is an instance of EventEmitter. For