thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_util_bufwriter.c - nifi-minifi-cpp - Git at Google

 /*
  *  Fast buffer writer with spare management.
  */

 #include "duk_internal.h"

 /*
  *  Macro support functions (use only macros in calling code)
  */

 DUK_LOCAL void duk__bw_update_ptrs(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t curr_offset, duk_size_t new_length) {
 	duk_uint8_t *p;

 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw_ctx != NULL);
 	DUK_UNREF(thr);

 	p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, bw_ctx->buf);
 	DUK_ASSERT(p != NULL || (DUK_HBUFFER_DYNAMIC_GET_SIZE(bw_ctx->buf) == 0 && curr_offset == 0 && new_length == 0));
 	bw_ctx->p = p + curr_offset;
 	bw_ctx->p_base = p;
 	bw_ctx->p_limit = p + new_length;
 }

 DUK_INTERNAL void duk_bw_init(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_hbuffer_dynamic *h_buf) {

 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw_ctx != NULL);
 	DUK_ASSERT(h_buf != NULL);
 	DUK_UNREF(thr);

 	bw_ctx->buf = h_buf;
 	duk__bw_update_ptrs(thr, bw_ctx, 0, DUK_HBUFFER_DYNAMIC_GET_SIZE(h_buf));
 }

 DUK_INTERNAL void duk_bw_init_pushbuf(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t buf_size) {
 	duk_context *ctx;

 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw_ctx != NULL);
 	ctx = (duk_context *) thr;

 	(void) duk_push_dynamic_buffer(ctx, buf_size);
 	bw_ctx->buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
 	duk__bw_update_ptrs(thr, bw_ctx, 0, buf_size);
 }

 /* Resize target buffer for requested size.  Called by the macro only when the
  * fast path test (= there is space) fails.
  */
 DUK_INTERNAL duk_uint8_t *duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz) {
 	duk_size_t curr_off;
 	duk_size_t add_sz;
 	duk_size_t new_sz;

 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw_ctx != NULL);

 	/* We could do this operation without caller updating bw_ctx->ptr,
 	 * but by writing it back here we can share code better.
 	 */

 	curr_off = (duk_size_t) (bw_ctx->p - bw_ctx->p_base);
 	add_sz = (curr_off >> DUK_BW_SPARE_SHIFT) + DUK_BW_SPARE_ADD;
 	new_sz = curr_off + sz + add_sz;
 	if (new_sz < curr_off) {
 		/* overflow */
 		DUK_ERROR_RANGE(thr, DUK_STR_BUFFER_TOO_LONG);
 		return NULL;  /* not reachable */
 	}
 #if 0  /* for manual torture testing: tight allocation, useful with valgrind */
 	new_sz = curr_off + sz;
 #endif

 	/* This is important to ensure dynamic buffer data pointer is not
 	 * NULL (which is possible if buffer size is zero), which in turn
 	 * causes portability issues with e.g. memmove() and memcpy().
 	 */
 	DUK_ASSERT(new_sz >= 1);

 	DUK_DD(DUK_DDPRINT("resize bufferwriter from %ld to %ld (add_sz=%ld)", (long) curr_off, (long) new_sz, (long) add_sz));

 	duk_hbuffer_resize(thr, bw_ctx->buf, new_sz);
 	duk__bw_update_ptrs(thr, bw_ctx, curr_off, new_sz);
 	return bw_ctx->p;
 }

 /* Make buffer compact, matching current written size. */
 DUK_INTERNAL void duk_bw_compact(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx) {
 	duk_size_t len;

 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw_ctx != NULL);
 	DUK_UNREF(thr);

 	len = (duk_size_t) (bw_ctx->p - bw_ctx->p_base);
 	duk_hbuffer_resize(thr, bw_ctx->buf, len);
 	duk__bw_update_ptrs(thr, bw_ctx, len, len);
 }

 DUK_INTERNAL void duk_bw_write_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len) {
 	duk_uint8_t *p_base;

 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw != NULL);
 	DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_UNREF(thr);

 	p_base = bw->p_base;
 	DUK_MEMCPY((void *) bw->p,
 	           (const void *) (p_base + src_off),
 	           (size_t) len);
 	bw->p += len;
 }

 DUK_INTERNAL void duk_bw_write_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len) {
 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw != NULL);
 	DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_UNREF(thr);

 	DUK_BW_ENSURE(thr, bw, len);
 	duk_bw_write_raw_slice(thr, bw, src_off, len);
 }

 DUK_INTERNAL void duk_bw_insert_raw_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len) {
 	duk_uint8_t *p_base;
 	duk_size_t buf_sz, move_sz;

 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw != NULL);
 	DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(buf != NULL);
 	DUK_UNREF(thr);

 	p_base = bw->p_base;
 	buf_sz = bw->p - p_base;
 	move_sz = buf_sz - dst_off;

 	DUK_ASSERT(p_base != NULL);  /* buffer size is >= 1 */
 	DUK_MEMMOVE((void *) (p_base + dst_off + len),
 	            (const void *) (p_base + dst_off),
 	            (size_t) move_sz);
 	DUK_MEMCPY((void *) (p_base + dst_off),
 	           (const void *) buf,
 	           (size_t) len);
 	bw->p += len;
 }

 DUK_INTERNAL void duk_bw_insert_ensure_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len) {
 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw != NULL);
 	DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(buf != NULL);
 	DUK_UNREF(thr);

 	DUK_BW_ENSURE(thr, bw, len);
 	duk_bw_insert_raw_bytes(thr, bw, dst_off, buf, len);
 }

 DUK_INTERNAL void duk_bw_insert_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len) {
 	duk_uint8_t *p_base;
 	duk_size_t buf_sz, move_sz;

 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw != NULL);
 	DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_UNREF(thr);

 	p_base = bw->p_base;

 	/* Don't support "straddled" source now. */
 	DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len);

 	if (dst_off <= src_off) {
 		/* Target is before source.  Source offset is expressed as
 		 * a "before change" offset.  Account for the memmove.
 		 */
 		src_off += len;
 	}

 	buf_sz = bw->p - p_base;
 	move_sz = buf_sz - dst_off;

 	DUK_ASSERT(p_base != NULL);  /* buffer size is >= 1 */
 	DUK_MEMMOVE((void *) (p_base + dst_off + len),
 	            (const void *) (p_base + dst_off),
 	            (size_t) move_sz);
 	DUK_MEMCPY((void *) (p_base + dst_off),
 	           (const void *) (p_base + src_off),
 	           (size_t) len);
 	bw->p += len;
 }

 DUK_INTERNAL void duk_bw_insert_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len) {
 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw != NULL);
 	DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_UNREF(thr);

 	/* Don't support "straddled" source now. */
 	DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len);

 	DUK_BW_ENSURE(thr, bw, len);
 	duk_bw_insert_raw_slice(thr, bw, dst_off, src_off, len);
 }

 DUK_INTERNAL duk_uint8_t *duk_bw_insert_raw_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) {
 	duk_uint8_t *p_base, *p_dst, *p_src;
 	duk_size_t buf_sz, move_sz;

 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw != NULL);
 	DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_UNREF(thr);

 	p_base = bw->p_base;
 	buf_sz = bw->p - p_base;
 	move_sz = buf_sz - off;
 	p_dst = p_base + off + len;
 	p_src = p_base + off;
 	DUK_MEMMOVE((void *) p_dst, (const void *) p_src, (size_t) move_sz);
 	return p_src;  /* point to start of 'reserved area' */
 }

 DUK_INTERNAL duk_uint8_t *duk_bw_insert_ensure_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) {
 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw != NULL);
 	DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_UNREF(thr);

 	DUK_BW_ENSURE(thr, bw, len);
 	return duk_bw_insert_raw_area(thr, bw, off, len);
 }

 DUK_INTERNAL void duk_bw_remove_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) {
 	duk_size_t move_sz;

 	duk_uint8_t *p_base;
 	duk_uint8_t *p_src;
 	duk_uint8_t *p_dst;

 	DUK_ASSERT(thr != NULL);
 	DUK_ASSERT(bw != NULL);
 	DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_ASSERT(off + len <= DUK_BW_GET_SIZE(thr, bw));
 	DUK_UNREF(thr);

 	p_base = bw->p_base;
 	p_dst = p_base + off;
 	p_src = p_dst + len;
 	move_sz = (duk_size_t) (bw->p - p_src);
 	DUK_MEMMOVE((void *) p_dst,
 	            (const void *) p_src,
 	            (size_t) move_sz);
 	bw->p -= len;
 }

 /*
  *  Macro support functions for reading/writing raw data.
  *
  *  These are done using mempcy to ensure they're valid even for unaligned
  *  reads/writes on platforms where alignment counts.  On x86 at least gcc
  *  is able to compile these into a bswap+mov.  "Always inline" is used to
  *  ensure these macros compile to minimal code.
  *
  *  Not really bufwriter related, but currently used together.
  */

 DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint16_t duk_raw_read_u16_be(duk_uint8_t **p) {
 	union {
 		duk_uint8_t b[2];
 		duk_uint16_t x;
 	} u;

 	DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 2);
 	u.x = DUK_NTOH16(u.x);
 	*p += 2;
 	return u.x;
 }

 DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint32_t duk_raw_read_u32_be(duk_uint8_t **p) {
 	union {
 		duk_uint8_t b[4];
 		duk_uint32_t x;
 	} u;

 	DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 4);
 	u.x = DUK_NTOH32(u.x);
 	*p += 4;
 	return u.x;
 }

 DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_raw_read_double_be(duk_uint8_t **p) {
 	duk_double_union du;
 	union {
 		duk_uint8_t b[4];
 		duk_uint32_t x;
 	} u;

 	DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 4);
 	u.x = DUK_NTOH32(u.x);
 	du.ui[DUK_DBL_IDX_UI0] = u.x;
 	DUK_MEMCPY((void *) u.b, (const void *) (*p + 4), (size_t) 4);
 	u.x = DUK_NTOH32(u.x);
 	du.ui[DUK_DBL_IDX_UI1] = u.x;
 	*p += 8;

 	return du.d;
 }

 DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u16_be(duk_uint8_t **p, duk_uint16_t val) {
 	union {
 		duk_uint8_t b[2];
 		duk_uint16_t x;
 	} u;

 	u.x = DUK_HTON16(val);
 	DUK_MEMCPY((void *) (*p), (const void *) u.b, (size_t) 2);
 	*p += 2;
 }

 DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u32_be(duk_uint8_t **p, duk_uint32_t val) {
 	union {
 		duk_uint8_t b[4];
 		duk_uint32_t x;
 	} u;

 	u.x = DUK_HTON32(val);
 	DUK_MEMCPY((void *) (*p), (const void *) u.b, (size_t) 4);
 	*p += 4;
 }

 DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_double_be(duk_uint8_t **p, duk_double_t val) {
 	duk_double_union du;
 	union {
 		duk_uint8_t b[4];
 		duk_uint32_t x;
 	} u;

 	du.d = val;
 	u.x = du.ui[DUK_DBL_IDX_UI0];
 	u.x = DUK_HTON32(u.x);
 	DUK_MEMCPY((void *) (*p), (const void *) u.b, (size_t) 4);
 	u.x = du.ui[DUK_DBL_IDX_UI1];
 	u.x = DUK_HTON32(u.x);
 	DUK_MEMCPY((void *) (*p + 4), (const void *) u.b, (size_t) 4);
 	*p += 8;
 }
	/*
	* Fast buffer writer with spare management.
	*/

	#include "duk_internal.h"

	/*
	* Macro support functions (use only macros in calling code)
	*/

	DUK_LOCAL void duk__bw_update_ptrs(duk_hthread thr, duk_bufwriter_ctx bw_ctx, duk_size_t curr_offset, duk_size_t new_length) {
	duk_uint8_t *p;

	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw_ctx != NULL);
	DUK_UNREF(thr);

	p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, bw_ctx->buf);
	DUK_ASSERT(p != NULL \|\| (DUK_HBUFFER_DYNAMIC_GET_SIZE(bw_ctx->buf) == 0 && curr_offset == 0 && new_length == 0));
	bw_ctx->p = p + curr_offset;
	bw_ctx->p_base = p;
	bw_ctx->p_limit = p + new_length;
	}

	DUK_INTERNAL void duk_bw_init(duk_hthread thr, duk_bufwriter_ctx bw_ctx, duk_hbuffer_dynamic *h_buf) {

	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw_ctx != NULL);
	DUK_ASSERT(h_buf != NULL);
	DUK_UNREF(thr);

	bw_ctx->buf = h_buf;
	duk__bw_update_ptrs(thr, bw_ctx, 0, DUK_HBUFFER_DYNAMIC_GET_SIZE(h_buf));
	}

	DUK_INTERNAL void duk_bw_init_pushbuf(duk_hthread thr, duk_bufwriter_ctx bw_ctx, duk_size_t buf_size) {
	duk_context *ctx;

	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw_ctx != NULL);
	ctx = (duk_context *) thr;

	(void) duk_push_dynamic_buffer(ctx, buf_size);
	bw_ctx->buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
	duk__bw_update_ptrs(thr, bw_ctx, 0, buf_size);
	}

	/* Resize target buffer for requested size. Called by the macro only when the
	* fast path test (= there is space) fails.
	*/
	DUK_INTERNAL duk_uint8_t duk_bw_resize(duk_hthread thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz) {
	duk_size_t curr_off;
	duk_size_t add_sz;
	duk_size_t new_sz;

	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw_ctx != NULL);

	/* We could do this operation without caller updating bw_ctx->ptr,
	* but by writing it back here we can share code better.
	*/

	curr_off = (duk_size_t) (bw_ctx->p - bw_ctx->p_base);
	add_sz = (curr_off >> DUK_BW_SPARE_SHIFT) + DUK_BW_SPARE_ADD;
	new_sz = curr_off + sz + add_sz;
	if (new_sz < curr_off) {
	/* overflow */
	DUK_ERROR_RANGE(thr, DUK_STR_BUFFER_TOO_LONG);
	return NULL; /* not reachable */
	}
	#if 0 /* for manual torture testing: tight allocation, useful with valgrind */
	new_sz = curr_off + sz;
	#endif

	/* This is important to ensure dynamic buffer data pointer is not
	* NULL (which is possible if buffer size is zero), which in turn
	* causes portability issues with e.g. memmove() and memcpy().
	*/
	DUK_ASSERT(new_sz >= 1);

	DUK_DD(DUK_DDPRINT("resize bufferwriter from %ld to %ld (add_sz=%ld)", (long) curr_off, (long) new_sz, (long) add_sz));

	duk_hbuffer_resize(thr, bw_ctx->buf, new_sz);
	duk__bw_update_ptrs(thr, bw_ctx, curr_off, new_sz);
	return bw_ctx->p;
	}

	/* Make buffer compact, matching current written size. */
	DUK_INTERNAL void duk_bw_compact(duk_hthread thr, duk_bufwriter_ctx bw_ctx) {
	duk_size_t len;

	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw_ctx != NULL);
	DUK_UNREF(thr);

	len = (duk_size_t) (bw_ctx->p - bw_ctx->p_base);
	duk_hbuffer_resize(thr, bw_ctx->buf, len);
	duk__bw_update_ptrs(thr, bw_ctx, len, len);
	}

	DUK_INTERNAL void duk_bw_write_raw_slice(duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t src_off, duk_size_t len) {
	duk_uint8_t *p_base;

	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw != NULL);
	DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
	DUK_UNREF(thr);

	p_base = bw->p_base;
	DUK_MEMCPY((void *) bw->p,
	(const void *) (p_base + src_off),
	(size_t) len);
	bw->p += len;
	}

	DUK_INTERNAL void duk_bw_write_ensure_slice(duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t src_off, duk_size_t len) {
	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw != NULL);
	DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
	DUK_UNREF(thr);

	DUK_BW_ENSURE(thr, bw, len);
	duk_bw_write_raw_slice(thr, bw, src_off, len);
	}

	DUK_INTERNAL void duk_bw_insert_raw_bytes(duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len) {
	duk_uint8_t *p_base;
	duk_size_t buf_sz, move_sz;

	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw != NULL);
	DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(buf != NULL);
	DUK_UNREF(thr);

	p_base = bw->p_base;
	buf_sz = bw->p - p_base;
	move_sz = buf_sz - dst_off;

	DUK_ASSERT(p_base != NULL); /* buffer size is >= 1 */
	DUK_MEMMOVE((void *) (p_base + dst_off + len),
	(const void *) (p_base + dst_off),
	(size_t) move_sz);
	DUK_MEMCPY((void *) (p_base + dst_off),
	(const void *) buf,
	(size_t) len);
	bw->p += len;
	}

	DUK_INTERNAL void duk_bw_insert_ensure_bytes(duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len) {
	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw != NULL);
	DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(buf != NULL);
	DUK_UNREF(thr);

	DUK_BW_ENSURE(thr, bw, len);
	duk_bw_insert_raw_bytes(thr, bw, dst_off, buf, len);
	}

	DUK_INTERNAL void duk_bw_insert_raw_slice(duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len) {
	duk_uint8_t *p_base;
	duk_size_t buf_sz, move_sz;

	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw != NULL);
	DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
	DUK_UNREF(thr);

	p_base = bw->p_base;

	/* Don't support "straddled" source now. */
	DUK_ASSERT(dst_off <= src_off \|\| dst_off >= src_off + len);

	if (dst_off <= src_off) {
	/* Target is before source. Source offset is expressed as
	* a "before change" offset. Account for the memmove.
	*/
	src_off += len;
	}

	buf_sz = bw->p - p_base;
	move_sz = buf_sz - dst_off;

	DUK_ASSERT(p_base != NULL); /* buffer size is >= 1 */
	DUK_MEMMOVE((void *) (p_base + dst_off + len),
	(const void *) (p_base + dst_off),
	(size_t) move_sz);
	DUK_MEMCPY((void *) (p_base + dst_off),
	(const void *) (p_base + src_off),
	(size_t) len);
	bw->p += len;
	}

	DUK_INTERNAL void duk_bw_insert_ensure_slice(duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len) {
	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw != NULL);
	DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
	DUK_UNREF(thr);

	/* Don't support "straddled" source now. */
	DUK_ASSERT(dst_off <= src_off \|\| dst_off >= src_off + len);

	DUK_BW_ENSURE(thr, bw, len);
	duk_bw_insert_raw_slice(thr, bw, dst_off, src_off, len);
	}

	DUK_INTERNAL duk_uint8_t duk_bw_insert_raw_area(duk_hthread thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) {
	duk_uint8_t p_base, p_dst, *p_src;
	duk_size_t buf_sz, move_sz;

	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw != NULL);
	DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_UNREF(thr);

	p_base = bw->p_base;
	buf_sz = bw->p - p_base;
	move_sz = buf_sz - off;
	p_dst = p_base + off + len;
	p_src = p_base + off;
	DUK_MEMMOVE((void ) p_dst, (const void ) p_src, (size_t) move_sz);
	return p_src; /* point to start of 'reserved area' */
	}

	DUK_INTERNAL duk_uint8_t duk_bw_insert_ensure_area(duk_hthread thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) {
	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw != NULL);
	DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_UNREF(thr);

	DUK_BW_ENSURE(thr, bw, len);
	return duk_bw_insert_raw_area(thr, bw, off, len);
	}

	DUK_INTERNAL void duk_bw_remove_raw_slice(duk_hthread thr, duk_bufwriter_ctx bw, duk_size_t off, duk_size_t len) {
	duk_size_t move_sz;

	duk_uint8_t *p_base;
	duk_uint8_t *p_src;
	duk_uint8_t *p_dst;

	DUK_ASSERT(thr != NULL);
	DUK_ASSERT(bw != NULL);
	DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
	DUK_ASSERT(off + len <= DUK_BW_GET_SIZE(thr, bw));
	DUK_UNREF(thr);

	p_base = bw->p_base;
	p_dst = p_base + off;
	p_src = p_dst + len;
	move_sz = (duk_size_t) (bw->p - p_src);
	DUK_MEMMOVE((void *) p_dst,
	(const void *) p_src,
	(size_t) move_sz);
	bw->p -= len;
	}

	/*
	* Macro support functions for reading/writing raw data.
	*
	* These are done using mempcy to ensure they're valid even for unaligned
	* reads/writes on platforms where alignment counts. On x86 at least gcc
	* is able to compile these into a bswap+mov. "Always inline" is used to
	* ensure these macros compile to minimal code.
	*
	* Not really bufwriter related, but currently used together.
	*/

	DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint16_t duk_raw_read_u16_be(duk_uint8_t **p) {
	union {
	duk_uint8_t b[2];
	duk_uint16_t x;
	} u;

	DUK_MEMCPY((void ) u.b, (const void ) (*p), (size_t) 2);
	u.x = DUK_NTOH16(u.x);
	*p += 2;
	return u.x;
	}

	DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint32_t duk_raw_read_u32_be(duk_uint8_t **p) {
	union {
	duk_uint8_t b[4];
	duk_uint32_t x;
	} u;

	DUK_MEMCPY((void ) u.b, (const void ) (*p), (size_t) 4);
	u.x = DUK_NTOH32(u.x);
	*p += 4;
	return u.x;
	}

	DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_raw_read_double_be(duk_uint8_t **p) {
	duk_double_union du;
	union {
	duk_uint8_t b[4];
	duk_uint32_t x;
	} u;

	DUK_MEMCPY((void ) u.b, (const void ) (*p), (size_t) 4);
	u.x = DUK_NTOH32(u.x);
	du.ui[DUK_DBL_IDX_UI0] = u.x;
	DUK_MEMCPY((void ) u.b, (const void ) (*p + 4), (size_t) 4);
	u.x = DUK_NTOH32(u.x);
	du.ui[DUK_DBL_IDX_UI1] = u.x;
	*p += 8;

	return du.d;
	}

	DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u16_be(duk_uint8_t **p, duk_uint16_t val) {
	union {
	duk_uint8_t b[2];
	duk_uint16_t x;
	} u;

	u.x = DUK_HTON16(val);
	DUK_MEMCPY((void ) (p), (const void *) u.b, (size_t) 2);
	*p += 2;
	}

	DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u32_be(duk_uint8_t **p, duk_uint32_t val) {
	union {
	duk_uint8_t b[4];
	duk_uint32_t x;
	} u;

	u.x = DUK_HTON32(val);
	DUK_MEMCPY((void ) (p), (const void *) u.b, (size_t) 4);
	*p += 4;
	}

	DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_double_be(duk_uint8_t **p, duk_double_t val) {
	duk_double_union du;
	union {
	duk_uint8_t b[4];
	duk_uint32_t x;
	} u;

	du.d = val;
	u.x = du.ui[DUK_DBL_IDX_UI0];
	u.x = DUK_HTON32(u.x);
	DUK_MEMCPY((void ) (p), (const void *) u.b, (size_t) 4);
	u.x = du.ui[DUK_DBL_IDX_UI1];
	u.x = DUK_HTON32(u.x);
	DUK_MEMCPY((void ) (p + 4), (const void *) u.b, (size_t) 4);
	*p += 8;
	}