/*

* Duktape debugger

*/

#include "duk_internal.h"

#if defined(DUK_USE_DEBUGGER_SUPPORT)

/*

* Assert helpers

*/

#if defined(DUK_USE_ASSERTIONS)

#define DUK__DBG_TPORT_ENTER() \

do { \

DUK_ASSERT(heap->dbg_calling_transport == 0); \

heap->dbg_calling_transport = 1; \

} while (0)

#define DUK__DBG_TPORT_EXIT() \

do { \

DUK_ASSERT(heap->dbg_calling_transport == 1); \

heap->dbg_calling_transport = 0; \

} while (0)

#else

#define DUK__DBG_TPORT_ENTER() \

do { \

} while (0)

#define DUK__DBG_TPORT_EXIT() \

do { \

} while (0)

#endif

/*

* Helper structs

*/

typedef union {

void *p;

duk_uint_t b[1];

/* Use b[] to access the size of the union, which is strictly not

* correct. Can't use fixed size unless there's feature detection

* for pointer byte size.

*/

} duk__ptr_union;

/*

* Detach handling

*/

#define DUK__SET_CONN_BROKEN(thr, reason) \

do { \

/* For now shared handler is fine. */ \

duk__debug_do_detach1((thr)->heap, (reason)); \

} while (0)

DUK_LOCAL void duk__debug_do_detach1(duk_heap *heap, duk_int_t reason) {

/* Can be called multiple times with no harm. Mark the transport

* bad (dbg_read_cb == NULL) and clear state except for the detached

* callback and the udata field. The detached callback is delayed

* to the message loop so that it can be called between messages;

* this avoids corner cases related to immediate debugger reattach

* inside the detached callback.

*/

if (heap->dbg_detaching) {

DUK_D(DUK_DPRINT("debugger already detaching, ignore detach1"));

return;

}

DUK_D(DUK_DPRINT("debugger transport detaching, marking transport broken"));

heap->dbg_detaching = 1; /* prevent multiple in-progress detaches */

if (heap->dbg_write_cb != NULL) {

duk_hthread *thr;

thr = heap->heap_thread;

DUK_ASSERT(thr != NULL);

duk_debug_write_notify(thr, DUK_DBG_CMD_DETACHING);

duk_debug_write_int(thr, reason);

duk_debug_write_eom(thr);

}

heap->dbg_read_cb = NULL;

heap->dbg_write_cb = NULL;

heap->dbg_peek_cb = NULL;

heap->dbg_read_flush_cb = NULL;

heap->dbg_write_flush_cb = NULL;

heap->dbg_request_cb = NULL;

/* heap->dbg_detached_cb: keep */

/* heap->dbg_udata: keep */

/* heap->dbg_processing: keep on purpose to avoid debugger re-entry in detaching state */

heap->dbg_state_dirty = 0;

heap->dbg_force_restart = 0;

heap->dbg_pause_flags = 0;

heap->dbg_pause_act = NULL;

heap->dbg_pause_startline = 0;

heap->dbg_have_next_byte = 0;

duk_debug_clear_paused(heap); /* XXX: some overlap with field inits above */

heap->dbg_state_dirty = 0; /* XXX: clear_paused sets dirty; rework? */

/* Ensure there are no stale active breakpoint pointers.

* Breakpoint list is currently kept - we could empty it

* here but we'd need to handle refcounts correctly, and

* we'd need a 'thr' reference for that.

*

* XXX: clear breakpoint on either attach or detach?

*/

heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL;

}

DUK_LOCAL void duk__debug_do_detach2(duk_heap *heap) {

duk_debug_detached_function detached_cb;

void *detached_udata;

duk_hthread *thr;

thr = heap->heap_thread;

if (thr == NULL) {

DUK_ASSERT(heap->dbg_detached_cb == NULL);

return;

}

/* Safe to call multiple times. */

detached_cb = heap->dbg_detached_cb;

detached_udata = heap->dbg_udata;

heap->dbg_detached_cb = NULL;

heap->dbg_udata = NULL;

if (detached_cb) {

/* Careful here: state must be wiped before the call

* so that we can cleanly handle a re-attach from

* inside the callback.

*/

DUK_D(DUK_DPRINT("detached during message loop, delayed call to detached_cb"));

detached_cb(thr, detached_udata);

}

heap->dbg_detaching = 0;

}

DUK_INTERNAL void duk_debug_do_detach(duk_heap *heap) {

duk__debug_do_detach1(heap, 0);

duk__debug_do_detach2(heap);

}

/* Called on a read/write error: NULL all callbacks except the detached

* callback so that we never accidentally call them after a read/write

* error has been indicated. This is especially important for the transport

* I/O callbacks to fulfill guaranteed callback semantics.

*/

DUK_LOCAL void duk__debug_null_most_callbacks(duk_hthread *thr) {

duk_heap *heap;

DUK_ASSERT(thr != NULL);

heap = thr->heap;

DUK_D(DUK_DPRINT("transport read/write error, NULL all callbacks expected detached"));

heap->dbg_read_cb = NULL;

heap->dbg_write_cb = NULL; /* this is especially critical to avoid another write call in detach1() */

heap->dbg_peek_cb = NULL;

heap->dbg_read_flush_cb = NULL;

heap->dbg_write_flush_cb = NULL;

heap->dbg_request_cb = NULL;

/* keep heap->dbg_detached_cb */

}

/*

* Pause handling

*/

DUK_LOCAL void duk__debug_set_pause_state(duk_hthread *thr, duk_heap *heap, duk_small_uint_t pause_flags) {

duk_uint_fast32_t line;

line = duk_debug_curr_line(thr);

if (line == 0) {

/* No line info for current function. */

duk_small_uint_t updated_flags;

updated_flags = pause_flags & ~(DUK_PAUSE_FLAG_LINE_CHANGE);

DUK_D(DUK_DPRINT("no line info for current activation, disable line-based pause flags: 0x%08lx -> 0x%08lx",

(long) pause_flags,

(long) updated_flags));

pause_flags = updated_flags;

}

heap->dbg_pause_flags = pause_flags;

heap->dbg_pause_act = thr->callstack_curr;

heap->dbg_pause_startline = (duk_uint32_t) line;

heap->dbg_state_dirty = 1;

DUK_D(DUK_DPRINT("set state for automatic pause triggers, flags=0x%08lx, act=%p, startline=%ld",

(long) heap->dbg_pause_flags,

(void *) heap->dbg_pause_act,

(long) heap->dbg_pause_startline));

}

/*

* Debug connection peek and flush primitives

*/

DUK_INTERNAL duk_bool_t duk_debug_read_peek(duk_hthread *thr) {

duk_heap *heap;

duk_bool_t ret;

DUK_ASSERT(thr != NULL);

heap = thr->heap;

DUK_ASSERT(heap != NULL);

if (heap->dbg_read_cb == NULL) {

DUK_D(DUK_DPRINT("attempt to peek in detached state, return zero (= no data)"));

return 0;

}

if (heap->dbg_peek_cb == NULL) {

DUK_DD(DUK_DDPRINT("no peek callback, return zero (= no data)"));

return 0;

}

DUK__DBG_TPORT_ENTER();

ret = (duk_bool_t) (heap->dbg_peek_cb(heap->dbg_udata) > 0);

DUK__DBG_TPORT_EXIT();

return ret;

}

DUK_INTERNAL void duk_debug_read_flush(duk_hthread *thr) {

duk_heap *heap;

DUK_ASSERT(thr != NULL);

heap = thr->heap;

DUK_ASSERT(heap != NULL);

if (heap->dbg_read_cb == NULL) {

DUK_D(DUK_DPRINT("attempt to read flush in detached state, ignore"));

return;

}

if (heap->dbg_read_flush_cb == NULL) {

DUK_DD(DUK_DDPRINT("no read flush callback, ignore"));

return;

}

DUK__DBG_TPORT_ENTER();

heap->dbg_read_flush_cb(heap->dbg_udata);

DUK__DBG_TPORT_EXIT();

}

DUK_INTERNAL void duk_debug_write_flush(duk_hthread *thr) {

duk_heap *heap;

DUK_ASSERT(thr != NULL);

heap = thr->heap;

DUK_ASSERT(heap != NULL);

if (heap->dbg_read_cb == NULL) {

DUK_D(DUK_DPRINT("attempt to write flush in detached state, ignore"));

return;

}

if (heap->dbg_write_flush_cb == NULL) {

DUK_DD(DUK_DDPRINT("no write flush callback, ignore"));

return;

}

DUK__DBG_TPORT_ENTER();

heap->dbg_write_flush_cb(heap->dbg_udata);

DUK__DBG_TPORT_EXIT();

}

/*

* Debug connection skip primitives

*/

/* Skip fully. */

DUK_INTERNAL void duk_debug_skip_bytes(duk_hthread *thr, duk_size_t length) {

duk_uint8_t dummy[64];

duk_size_t now;

DUK_ASSERT(thr != NULL);

while (length > 0) {

now = (length > sizeof(dummy) ? sizeof(dummy) : length);

duk_debug_read_bytes(thr, dummy, now);

length -= now;

}

}

DUK_INTERNAL void duk_debug_skip_byte(duk_hthread *thr) {

DUK_ASSERT(thr != NULL);

(void) duk_debug_read_byte(thr);

}

/*

* Debug connection read primitives

*/

/* Peek ahead in the stream one byte. */

DUK_INTERNAL uint8_t duk_debug_peek_byte(duk_hthread *thr) {

/* It is important not to call this if the last byte read was an EOM.

* Reading ahead in this scenario would cause unnecessary blocking if

* another message is not available.

*/

duk_uint8_t x;

x = duk_debug_read_byte(thr);

thr->heap->dbg_have_next_byte = 1;

thr->heap->dbg_next_byte = x;

return x;

}

/* Read fully. */

DUK_INTERNAL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_size_t length) {

duk_heap *heap;

duk_uint8_t *p;

duk_size_t left;

duk_size_t got;

DUK_ASSERT(thr != NULL);

heap = thr->heap;

DUK_ASSERT(heap != NULL);

DUK_ASSERT(data != NULL);

if (heap->dbg_read_cb == NULL) {

DUK_D(DUK_DPRINT("attempt to read %ld bytes in detached state, return zero data", (long) length));

goto fail;

}

/* NOTE: length may be zero */

p = data;

if (length >= 1 && heap->dbg_have_next_byte) {

heap->dbg_have_next_byte = 0;

*p++ = heap->dbg_next_byte;

}

for (;;) {

left = (duk_size_t) ((data + length) - p);

if (left == 0) {

break;

}

DUK_ASSERT(heap->dbg_read_cb != NULL);

DUK_ASSERT(left >= 1);

#if defined(DUK_USE_DEBUGGER_TRANSPORT_TORTURE)

left = 1;

#endif

DUK__DBG_TPORT_ENTER();

got = heap->dbg_read_cb(heap->dbg_udata, (char *) p, left);

DUK__DBG_TPORT_EXIT();

if (got == 0 || got > left) {

DUK_D(DUK_DPRINT("connection error during read, return zero data"));

duk__debug_null_most_callbacks(thr); /* avoid calling write callback in detach1() */

DUK__SET_CONN_BROKEN(thr, 1);

goto fail;

}

p += got;

}

return;

fail:

duk_memzero((void *) data, (size_t) length);

}

DUK_INTERNAL duk_uint8_t duk_debug_read_byte(duk_hthread *thr) {

duk_uint8_t x;

x = 0; /* just in case callback is broken and won't write 'x' */

duk_debug_read_bytes(thr, &x, 1);

return x;

}

DUK_LOCAL duk_uint32_t duk__debug_read_uint32_raw(duk_hthread *thr) {

duk_uint8_t buf[4];

DUK_ASSERT(thr != NULL);

duk_debug_read_bytes(thr, buf, 4);

return ((duk_uint32_t) buf[0] << 24) | ((duk_uint32_t) buf[1] << 16) | ((duk_uint32_t) buf[2] << 8) | (duk_uint32_t) buf[3];

}

DUK_LOCAL duk_int32_t duk__debug_read_int32_raw(duk_hthread *thr) {

return (duk_int32_t) duk__debug_read_uint32_raw(thr);

}

DUK_LOCAL duk_uint16_t duk__debug_read_uint16_raw(duk_hthread *thr) {

duk_uint8_t buf[2];

DUK_ASSERT(thr != NULL);

duk_debug_read_bytes(thr, buf, 2);

return ((duk_uint16_t) buf[0] << 8) | (duk_uint16_t) buf[1];

}

DUK_INTERNAL duk_int32_t duk_debug_read_int(duk_hthread *thr) {

duk_small_uint_t x;

duk_small_uint_t t;

DUK_ASSERT(thr != NULL);

x = duk_debug_read_byte(thr);

if (x >= 0xc0) {

t = duk_debug_read_byte(thr);

return (duk_int32_t) (((x - 0xc0) << 8) + t);

} else if (x >= 0x80) {

return (duk_int32_t) (x - 0x80);

} else if (x == DUK_DBG_IB_INT4) {

return (duk_int32_t) duk__debug_read_uint32_raw(thr);

}

DUK_D(DUK_DPRINT("debug connection error: failed to decode int"));

DUK__SET_CONN_BROKEN(thr, 1);

return 0;

}

DUK_LOCAL duk_hstring *duk__debug_read_hstring_raw(duk_hthread *thr, duk_uint32_t len) {

duk_uint8_t buf[31];

duk_uint8_t *p;

if (len <= sizeof(buf)) {

duk_debug_read_bytes(thr, buf, (duk_size_t) len);

duk_push_lstring(thr, (const char *) buf, (duk_size_t) len);

} else {

p = (duk_uint8_t *) duk_push_fixed_buffer(thr, (duk_size_t) len); /* zero for paranoia */

DUK_ASSERT(p != NULL);

duk_debug_read_bytes(thr, p, (duk_size_t) len);

(void) duk_buffer_to_string(thr, -1); /* Safety relies on debug client, which is OK. */

}

return duk_require_hstring(thr, -1);

}

DUK_INTERNAL duk_hstring *duk_debug_read_hstring(duk_hthread *thr) {

duk_small_uint_t x;

duk_uint32_t len;

DUK_ASSERT(thr != NULL);

x = duk_debug_read_byte(thr);

if (x >= 0x60 && x <= 0x7f) {

/* For short strings, use a fixed temp buffer. */

len = (duk_uint32_t) (x - 0x60);

} else if (x == DUK_DBG_IB_STR2) {

len = (duk_uint32_t) duk__debug_read_uint16_raw(thr);

} else if (x == DUK_DBG_IB_STR4) {

len = (duk_uint32_t) duk__debug_read_uint32_raw(thr);

} else {

goto fail;

}

return duk__debug_read_hstring_raw(thr, len);

fail:

DUK_D(DUK_DPRINT("debug connection error: failed to decode int"));

DUK__SET_CONN_BROKEN(thr, 1);

duk_push_hstring_empty(thr); /* always push some string */

return duk_require_hstring(thr, -1);

}

DUK_LOCAL duk_hbuffer *duk__debug_read_hbuffer_raw(duk_hthread *thr, duk_uint32_t len) {

duk_uint8_t *p;

p = (duk_uint8_t *) duk_push_fixed_buffer(thr, (duk_size_t) len); /* zero for paranoia */

DUK_ASSERT(p != NULL);

duk_debug_read_bytes(thr, p, (duk_size_t) len);

return duk_require_hbuffer(thr, -1);

}

DUK_LOCAL void *duk__debug_read_pointer_raw(duk_hthread *thr) {

duk_small_uint_t x;

duk__ptr_union pu;

DUK_ASSERT(thr != NULL);

x = duk_debug_read_byte(thr);

if (x != sizeof(pu)) {

goto fail;

}

duk_debug_read_bytes(thr, (duk_uint8_t *) &pu.p, sizeof(pu));

#if defined(DUK_USE_INTEGER_LE)

duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu));

#endif

return (void *) pu.p;

fail:

DUK_D(DUK_DPRINT("debug connection error: failed to decode pointer"));

DUK__SET_CONN_BROKEN(thr, 1);

return (void *) NULL;

}

DUK_LOCAL duk_double_t duk__debug_read_double_raw(duk_hthread *thr) {

duk_double_union du;

DUK_ASSERT(sizeof(du.uc) == 8);

duk_debug_read_bytes(thr, (duk_uint8_t *) du.uc, sizeof(du.uc));

DUK_DBLUNION_DOUBLE_NTOH(&du);

return du.d;

}

#if 0

DUK_INTERNAL duk_heaphdr *duk_debug_read_heapptr(duk_hthread *thr) {

duk_small_uint_t x;

DUK_ASSERT(thr != NULL);

x = duk_debug_read_byte(thr);

if (x != DUK_DBG_IB_HEAPPTR) {

goto fail;

}

return (duk_heaphdr *) duk__debug_read_pointer_raw(thr);

fail:

DUK_D(DUK_DPRINT("debug connection error: failed to decode heapptr"));

DUK__SET_CONN_BROKEN(thr, 1);

return NULL;

}

#endif

DUK_INTERNAL duk_heaphdr *duk_debug_read_any_ptr(duk_hthread *thr) {

duk_small_uint_t x;

DUK_ASSERT(thr != NULL);

x = duk_debug_read_byte(thr);

switch (x) {

case DUK_DBG_IB_OBJECT:

case DUK_DBG_IB_POINTER:

case DUK_DBG_IB_HEAPPTR:

/* Accept any pointer-like value; for 'object' dvalue, read

* and ignore the class number.

*/

if (x == DUK_DBG_IB_OBJECT) {

duk_debug_skip_byte(thr);

}

break;

default:

goto fail;

}

return (duk_heaphdr *) duk__debug_read_pointer_raw(thr);

fail:

DUK_D(DUK_DPRINT("debug connection error: failed to decode any pointer (object, pointer, heapptr)"));

DUK__SET_CONN_BROKEN(thr, 1);

return NULL;

}

DUK_INTERNAL duk_tval *duk_debug_read_tval(duk_hthread *thr) {

duk_uint8_t x;

duk_uint_t t;

duk_uint32_t len;

DUK_ASSERT(thr != NULL);

x = duk_debug_read_byte(thr);

if (x >= 0xc0) {

t = (duk_uint_t) (x - 0xc0);

t = (t << 8) + duk_debug_read_byte(thr);

duk_push_uint(thr, (duk_uint_t) t);

goto return_ptr;

}

if (x >= 0x80) {

duk_push_uint(thr, (duk_uint_t) (x - 0x80));

goto return_ptr;

}

if (x >= 0x60) {

len = (duk_uint32_t) (x - 0x60);

duk__debug_read_hstring_raw(thr, len);

goto return_ptr;

}

switch (x) {

case DUK_DBG_IB_INT4: {

duk_int32_t i = duk__debug_read_int32_raw(thr);

duk_push_i32(thr, i);

break;

}

case DUK_DBG_IB_STR4: {

len = duk__debug_read_uint32_raw(thr);

duk__debug_read_hstring_raw(thr, len);

break;

}

case DUK_DBG_IB_STR2: {

len = duk__debug_read_uint16_raw(thr);

duk__debug_read_hstring_raw(thr, len);

break;

}

case DUK_DBG_IB_BUF4: {

len = duk__debug_read_uint32_raw(thr);

duk__debug_read_hbuffer_raw(thr, len);

break;

}

case DUK_DBG_IB_BUF2: {

len = duk__debug_read_uint16_raw(thr);

duk__debug_read_hbuffer_raw(thr, len);

break;

}

case DUK_DBG_IB_UNDEFINED: {

duk_push_undefined(thr);

break;

}

case DUK_DBG_IB_NULL: {

duk_push_null(thr);

break;

}

case DUK_DBG_IB_TRUE: {

duk_push_true(thr);

break;

}

case DUK_DBG_IB_FALSE: {

duk_push_false(thr);

break;

}

case DUK_DBG_IB_NUMBER: {

duk_double_t d;

d = duk__debug_read_double_raw(thr);

duk_push_number(thr, d);

break;

}

case DUK_DBG_IB_OBJECT: {

duk_heaphdr *h;

duk_debug_skip_byte(thr);

h = (duk_heaphdr *) duk__debug_read_pointer_raw(thr);

duk_push_heapptr(thr, (void *) h);

break;

}

case DUK_DBG_IB_POINTER: {

void *ptr;

ptr = duk__debug_read_pointer_raw(thr);

duk_push_pointer(thr, ptr);

break;

}

case DUK_DBG_IB_LIGHTFUNC: {

/* XXX: Not needed for now, so not implemented. Note that

* function pointers may have different size/layout than

* a void pointer.

*/

DUK_D(DUK_DPRINT("reading lightfunc values unimplemented"));

goto fail;

}

case DUK_DBG_IB_HEAPPTR: {

duk_heaphdr *h;

h = (duk_heaphdr *) duk__debug_read_pointer_raw(thr);

duk_push_heapptr(thr, (void *) h);

break;

}

case DUK_DBG_IB_UNUSED: /* unused: not accepted in inbound messages */

default:

goto fail;

}

return_ptr:

return DUK_GET_TVAL_NEGIDX(thr, -1);

fail:

DUK_D(DUK_DPRINT("debug connection error: failed to decode tval"));

DUK__SET_CONN_BROKEN(thr, 1);

return NULL;

}

/*

* Debug connection write primitives

*/

/* Write fully. */

DUK_INTERNAL void duk_debug_write_bytes(duk_hthread *thr, const duk_uint8_t *data, duk_size_t length) {

duk_heap *heap;

const duk_uint8_t *p;

duk_size_t left;

duk_size_t got;

DUK_ASSERT(thr != NULL);

DUK_ASSERT(length == 0 || data != NULL);

heap = thr->heap;

DUK_ASSERT(heap != NULL);

if (heap->dbg_write_cb == NULL) {

DUK_D(DUK_DPRINT("attempt to write %ld bytes in detached state, ignore", (long) length));

return;

}

if (length == 0) {

/* Avoid doing an actual write callback with length == 0,

* because that's reserved for a write flush.

*/

return;

}

DUK_ASSERT(data != NULL);

p = data;

for (;;) {

left = (duk_size_t) ((data + length) - p);

if (left == 0) {

break;

}

DUK_ASSERT(heap->dbg_write_cb != NULL);

DUK_ASSERT(left >= 1);

#if defined(DUK_USE_DEBUGGER_TRANSPORT_TORTURE)

left = 1;

#endif

DUK__DBG_TPORT_ENTER();

got = heap->dbg_write_cb(heap->dbg_udata, (const char *) p, left);

DUK__DBG_TPORT_EXIT();

if (got == 0 || got > left) {

duk__debug_null_most_callbacks(thr); /* avoid calling write callback in detach1() */

DUK_D(DUK_DPRINT("connection error during write"));

DUK__SET_CONN_BROKEN(thr, 1);

return;

}

p += got;

}

}

DUK_INTERNAL void duk_debug_write_byte(duk_hthread *thr, duk_uint8_t x) {

duk_debug_write_bytes(thr, (const duk_uint8_t *) &x, 1);

}

DUK_INTERNAL void duk_debug_write_unused(duk_hthread *thr) {

duk_debug_write_byte(thr, DUK_DBG_IB_UNUSED);

}

DUK_INTERNAL void duk_debug_write_undefined(duk_hthread *thr) {

duk_debug_write_byte(thr, DUK_DBG_IB_UNDEFINED);

}

#if defined(DUK_USE_DEBUGGER_INSPECT)

DUK_INTERNAL void duk_debug_write_null(duk_hthread *thr) {

duk_debug_write_byte(thr, DUK_DBG_IB_NULL);

}

#endif

DUK_INTERNAL void duk_debug_write_boolean(duk_hthread *thr, duk_uint_t val) {

duk_debug_write_byte(thr, val ? DUK_DBG_IB_TRUE : DUK_DBG_IB_FALSE);

}

/* Write signed 32-bit integer. */

DUK_INTERNAL void duk_debug_write_int(duk_hthread *thr, duk_int32_t x) {

duk_uint8_t buf[5];

duk_size_t len;

DUK_ASSERT(thr != NULL);

if (x >= 0 && x <= 0x3fL) {

buf[0] = (duk_uint8_t) (0x80 + x);

len = 1;

} else if (x >= 0 && x <= 0x3fffL) {

buf[0] = (duk_uint8_t) (0xc0 + (x >> 8));

buf[1] = (duk_uint8_t) (x & 0xff);

len = 2;

} else {

/* Signed integers always map to 4 bytes now. */

buf[0] = (duk_uint8_t) DUK_DBG_IB_INT4;

buf[1] = (duk_uint8_t) ((x >> 24) & 0xff);

buf[2] = (duk_uint8_t) ((x >> 16) & 0xff);

buf[3] = (duk_uint8_t) ((x >> 8) & 0xff);

buf[4] = (duk_uint8_t) (x & 0xff);

len = 5;

}

duk_debug_write_bytes(thr, buf, len);

}

/* Write unsigned 32-bit integer. */

DUK_INTERNAL void duk_debug_write_uint(duk_hthread *thr, duk_uint32_t x) {

/* The debugger protocol doesn't support a plain integer encoding for

* the full 32-bit unsigned range (only 32-bit signed). For now,

* unsigned 32-bit values simply written as signed ones. This is not

* a concrete issue except for 32-bit heaphdr fields. Proper solutions

* would be to (a) write such integers as IEEE doubles or (b) add an

* unsigned 32-bit dvalue.

*/

if (x >= 0x80000000UL) {

DUK_D(DUK_DPRINT("writing unsigned integer 0x%08lx as signed integer", (long) x));

}

duk_debug_write_int(thr, (duk_int32_t) x);

}

DUK_INTERNAL void duk_debug_write_strbuf(duk_hthread *thr, const char *data, duk_size_t length, duk_uint8_t marker_base) {

duk_uint8_t buf[5];

duk_size_t buflen;

DUK_ASSERT(thr != NULL);

DUK_ASSERT(length == 0 || data != NULL);

if (length <= 0x1fUL && marker_base == DUK_DBG_IB_STR4) {

/* For strings, special form for short lengths. */

buf[0] = (duk_uint8_t) (0x60 + length);

buflen = 1;

} else if (length <= 0xffffUL) {

buf[0] = (duk_uint8_t) (marker_base + 1);

buf[1] = (duk_uint8_t) (length >> 8);

buf[2] = (duk_uint8_t) (length & 0xff);

buflen = 3;

} else {

buf[0] = (duk_uint8_t) marker_base;

buf[1] = (duk_uint8_t) (length >> 24);

buf[2] = (duk_uint8_t) ((length >> 16) & 0xff);

buf[3] = (duk_uint8_t) ((length >> 8) & 0xff);

buf[4] = (duk_uint8_t) (length & 0xff);

buflen = 5;

}

duk_debug_write_bytes(thr, (const duk_uint8_t *) buf, buflen);

duk_debug_write_bytes(thr, (const duk_uint8_t *) data, length);

}

DUK_INTERNAL void duk_debug_write_string(duk_hthread *thr, const char *data, duk_size_t length) {

duk_debug_write_strbuf(thr, data, length, DUK_DBG_IB_STR4);

}

DUK_INTERNAL void duk_debug_write_cstring(duk_hthread *thr, const char *data) {

DUK_ASSERT(thr != NULL);

duk_debug_write_string(thr, data, data ? DUK_STRLEN(data) : 0);

}

DUK_INTERNAL void duk_debug_write_hstring(duk_hthread *thr, duk_hstring *h) {

DUK_ASSERT(thr != NULL);

/* XXX: differentiate null pointer from empty string? */

duk_debug_write_string(thr,

(h != NULL ? (const char *) DUK_HSTRING_GET_DATA(h) : NULL),

(h != NULL ? (duk_size_t) DUK_HSTRING_GET_BYTELEN(h) : 0));

}

DUK_LOCAL void duk__debug_write_hstring_safe_top(duk_hthread *thr) {

duk_debug_write_hstring(thr, duk_safe_to_hstring(thr, -1));

}

DUK_INTERNAL void duk_debug_write_buffer(duk_hthread *thr, const char *data, duk_size_t length) {

duk_debug_write_strbuf(thr, data, length, DUK_DBG_IB_BUF4);

}

DUK_INTERNAL void duk_debug_write_hbuffer(duk_hthread *thr, duk_hbuffer *h) {

DUK_ASSERT(thr != NULL);

duk_debug_write_buffer(thr,

(h != NULL ? (const char *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h) : NULL),

(h != NULL ? (duk_size_t) DUK_HBUFFER_GET_SIZE(h) : 0));

}

DUK_LOCAL void duk__debug_write_pointer_raw(duk_hthread *thr, void *ptr, duk_uint8_t ibyte) {

duk_uint8_t buf[2];

duk__ptr_union pu;

DUK_ASSERT(thr != NULL);

DUK_ASSERT(sizeof(ptr) >= 1 && sizeof(ptr) <= 16);

/* ptr may be NULL */

buf[0] = ibyte;

buf[1] = sizeof(pu);

duk_debug_write_bytes(thr, buf, 2);

pu.p = (void *) ptr;

#if defined(DUK_USE_INTEGER_LE)

duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu));

#endif

duk_debug_write_bytes(thr, (const duk_uint8_t *) &pu.p, (duk_size_t) sizeof(pu));

}

DUK_INTERNAL void duk_debug_write_pointer(duk_hthread *thr, void *ptr) {

duk__debug_write_pointer_raw(thr, ptr, DUK_DBG_IB_POINTER);

}

#if defined(DUK_USE_DEBUGGER_DUMPHEAP) || defined(DUK_USE_DEBUGGER_INSPECT)

DUK_INTERNAL void duk_debug_write_heapptr(duk_hthread *thr, duk_heaphdr *h) {

duk__debug_write_pointer_raw(thr, (void *) h, DUK_DBG_IB_HEAPPTR);

}

#endif /* DUK_USE_DEBUGGER_DUMPHEAP || DUK_USE_DEBUGGER_INSPECT */

DUK_INTERNAL void duk_debug_write_hobject(duk_hthread *thr, duk_hobject *obj) {

duk_uint8_t buf[3];

duk__ptr_union pu;

DUK_ASSERT(thr != NULL);

DUK_ASSERT(sizeof(obj) >= 1 && sizeof(obj) <= 16);

DUK_ASSERT(obj != NULL);

buf[0] = DUK_DBG_IB_OBJECT;

buf[1] = (duk_uint8_t) DUK_HOBJECT_GET_CLASS_NUMBER(obj);

buf[2] = sizeof(pu);

duk_debug_write_bytes(thr, buf, 3);

pu.p = (void *) obj;

#if defined(DUK_USE_INTEGER_LE)

duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu));

#endif

duk_debug_write_bytes(thr, (const duk_uint8_t *) &pu.p, (duk_size_t) sizeof(pu));

}

DUK_INTERNAL void duk_debug_write_tval(duk_hthread *thr, duk_tval *tv) {

duk_c_function lf_func;

duk_small_uint_t lf_flags;

duk_uint8_t buf[4];

duk_double_union du1;

duk_double_union du2;

duk_int32_t i32;

DUK_ASSERT(thr != NULL);

DUK_ASSERT(tv != NULL);

switch (DUK_TVAL_GET_TAG(tv)) {

case DUK_TAG_UNDEFINED:

duk_debug_write_byte(thr, DUK_DBG_IB_UNDEFINED);

break;

case DUK_TAG_UNUSED:

duk_debug_write_byte(thr, DUK_DBG_IB_UNUSED);

break;

case DUK_TAG_NULL:

duk_debug_write_byte(thr, DUK_DBG_IB_NULL);

break;

case DUK_TAG_BOOLEAN:

DUK_ASSERT(DUK_TVAL_GET_BOOLEAN(tv) == 0 || DUK_TVAL_GET_BOOLEAN(tv) == 1);

duk_debug_write_boolean(thr, DUK_TVAL_GET_BOOLEAN(tv));

break;

case DUK_TAG_POINTER:

duk_debug_write_pointer(thr, (void *) DUK_TVAL_GET_POINTER(tv));

break;

case DUK_TAG_LIGHTFUNC:

DUK_TVAL_GET_LIGHTFUNC(tv, lf_func, lf_flags);

buf[0] = DUK_DBG_IB_LIGHTFUNC;

buf[1] = (duk_uint8_t) (lf_flags >> 8);

buf[2] = (duk_uint8_t) (lf_flags & 0xff);

buf[3] = sizeof(lf_func);

duk_debug_write_bytes(thr, buf, 4);

duk_debug_write_bytes(thr, (const duk_uint8_t *) &lf_func, sizeof(lf_func));

break;

case DUK_TAG_STRING:

duk_debug_write_hstring(thr, DUK_TVAL_GET_STRING(tv));

break;

case DUK_TAG_OBJECT:

duk_debug_write_hobject(thr, DUK_TVAL_GET_OBJECT(tv));

break;

case DUK_TAG_BUFFER:

duk_debug_write_hbuffer(thr, DUK_TVAL_GET_BUFFER(tv));

break;

#if defined(DUK_USE_FASTINT)

case DUK_TAG_FASTINT:

#endif

default:

/* Numbers are normalized to big (network) endian. We can

* (but are not required) to use integer dvalues when there's

* no loss of precision.

*

* XXX: share check with other code; this check is slow but

* reliable and doesn't require careful exponent/mantissa

* mask tricks as in the fastint downgrade code.

*/

DUK_ASSERT(!DUK_TVAL_IS_UNUSED(tv));

DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));

du1.d = DUK_TVAL_GET_NUMBER(tv);

i32 = (duk_int32_t) du1.d;

du2.d = (duk_double_t) i32;

DUK_DD(DUK_DDPRINT("i32=%ld du1=%02x%02x%02x%02x%02x%02x%02x%02x "

"du2=%02x%02x%02x%02x%02x%02x%02x%02x",

(long) i32,

(unsigned int) du1.uc[0],

(unsigned int) du1.uc[1],

(unsigned int) du1.uc[2],

(unsigned int) du1.uc[3],

(unsigned int) du1.uc[4],

(unsigned int) du1.uc[5],

(unsigned int) du1.uc[6],

(unsigned int) du1.uc[7],

(unsigned int) du2.uc[0],

(unsigned int) du2.uc[1],

(unsigned int) du2.uc[2],

(unsigned int) du2.uc[3],

(unsigned int) du2.uc[4],

(unsigned int) du2.uc[5],

(unsigned int) du2.uc[6],

(unsigned int) du2.uc[7]));

if (duk_memcmp((const void *) du1.uc, (const void *) du2.uc, sizeof(du1.uc)) == 0) {

duk_debug_write_int(thr, i32);

} else {

DUK_DBLUNION_DOUBLE_HTON(&du1);

duk_debug_write_byte(thr, DUK_DBG_IB_NUMBER);

duk_debug_write_bytes(thr, (const duk_uint8_t *) du1.uc, sizeof(du1.uc));

}

}

}

#if defined(DUK_USE_DEBUGGER_DUMPHEAP)

/* Variant for writing duk_tvals so that any heap allocated values are

* written out as tagged heap pointers.

*/

DUK_LOCAL void duk__debug_write_tval_heapptr(duk_hthread *thr, duk_tval *tv) {

if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {

duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);

duk_debug_write_heapptr(thr, h);

} else {

duk_debug_write_tval(thr, tv);

}

}

#endif /* DUK_USE_DEBUGGER_DUMPHEAP */

/*

* Debug connection message write helpers

*/

#if 0 /* unused */