duk_util_bufwriter.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Functions
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_INTERNAL void	duk_bw_init (duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_hbuffer_dynamic *h_buf)
DUK_INTERNAL void	duk_bw_init_pushbuf (duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t buf_size)
DUK_INTERNAL duk_uint8_t *	duk_bw_resize (duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz)
DUK_INTERNAL void	duk_bw_compact (duk_hthread *thr, duk_bufwriter_ctx *bw_ctx)
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_INTERNAL void	duk_bw_write_ensure_slice (duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t 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_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_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_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_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_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_INTERNAL void	duk_bw_remove_raw_slice (duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len)
DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint16_t	duk_raw_read_u16_be (duk_uint8_t **p)
DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint32_t	duk_raw_read_u32_be (duk_uint8_t **p)
DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t	duk_raw_read_double_be (duk_uint8_t **p)
DUK_INTERNAL DUK_ALWAYS_INLINE void	duk_raw_write_u16_be (duk_uint8_t **p, duk_uint16_t val)
DUK_INTERNAL DUK_ALWAYS_INLINE void	duk_raw_write_u32_be (duk_uint8_t **p, duk_uint32_t val)
DUK_INTERNAL DUK_ALWAYS_INLINE void	duk_raw_write_double_be (duk_uint8_t **p, duk_double_t val)

Function Documentation

duk__bw_update_ptrs()

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 )

Definition at line 11 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                                               {
    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;
}

References duk_bufwriter_ctx::buf, DUK_ASSERT, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR, DUK_HBUFFER_DYNAMIC_GET_SIZE, DUK_UNREF, duk_hthread::heap, NULL, duk_bufwriter_ctx::p, duk_bufwriter_ctx::p_base, and duk_bufwriter_ctx::p_limit.

Referenced by duk_bw_compact(), duk_bw_init(), duk_bw_init_pushbuf(), and duk_bw_resize().

duk_bw_compact()

DUK_INTERNAL void duk_bw_compact	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw_ctx )

Definition at line 89 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                              {
    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);
}

References duk_bufwriter_ctx::buf, duk__bw_update_ptrs(), DUK_ASSERT, duk_hbuffer_resize(), DUK_UNREF, NULL, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.

duk_bw_init()

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

Definition at line 25 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                       {
 
    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));
}

References duk_bufwriter_ctx::buf, duk__bw_update_ptrs(), DUK_ASSERT, DUK_HBUFFER_DYNAMIC_GET_SIZE, DUK_UNREF, and NULL.

duk_bw_init_pushbuf()

DUK_INTERNAL void duk_bw_init_pushbuf	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw_ctx,
		duk_size_t	buf_size )

Definition at line 36 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                        {
    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);
}

References duk_bufwriter_ctx::buf, duk__bw_update_ptrs(), DUK_ASSERT, duk_get_hbuffer(), duk_push_dynamic_buffer, and NULL.

duk_bw_insert_ensure_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 )

Definition at line 236 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                                             {
    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);
}

References DUK_ASSERT, DUK_BW_ENSURE, DUK_BW_GET_SIZE, duk_bw_insert_raw_area(), DUK_UNREF, and NULL.

duk_bw_insert_ensure_bytes()

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 )

Definition at line 154 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                                                                  {
    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);
}

References DUK_ASSERT, DUK_BW_ENSURE, DUK_BW_GET_SIZE, duk_bw_insert_raw_bytes(), DUK_UNREF, and NULL.

duk_bw_insert_ensure_slice()

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 )

Definition at line 202 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                                                              {
    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);
}

References DUK_ASSERT, DUK_BW_ENSURE, DUK_BW_GET_SIZE, duk_bw_insert_raw_slice(), DUK_UNREF, and NULL.

duk_bw_insert_raw_area()

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 )

Definition at line 218 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                                          {
    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' */
}

References DUK_ASSERT, DUK_BW_GET_SIZE, DUK_MEMMOVE, DUK_UNREF, NULL, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.

Referenced by duk_bw_insert_ensure_area().

duk_bw_insert_raw_bytes()

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 )

Definition at line 130 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                                                               {
    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;
}

References DUK_ASSERT, DUK_BW_GET_SIZE, DUK_MEMCPY, DUK_MEMMOVE, DUK_UNREF, NULL, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.

Referenced by duk_bw_insert_ensure_bytes().

duk_bw_insert_raw_slice()

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 )

Definition at line 165 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                                                           {
    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;
}

References DUK_ASSERT, DUK_BW_GET_SIZE, DUK_MEMCPY, DUK_MEMMOVE, DUK_UNREF, NULL, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.

Referenced by duk_bw_insert_ensure_slice().

duk_bw_remove_raw_slice()

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

Definition at line 246 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                                   {
    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;
}

References DUK_ASSERT, DUK_BW_GET_SIZE, DUK_MEMMOVE, DUK_UNREF, NULL, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.

duk_bw_resize()

DUK_INTERNAL duk_uint8_t * duk_bw_resize	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw_ctx,
		duk_size_t	sz )

Definition at line 51 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                    {
    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;
}

References duk_bufwriter_ctx::buf, duk__bw_update_ptrs(), DUK_ASSERT, DUK_BW_SPARE_ADD, DUK_BW_SPARE_SHIFT, DUK_DD, DUK_DDPRINT, DUK_ERROR_RANGE, duk_hbuffer_resize(), DUK_STR_BUFFER_TOO_LONG, NULL, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.

duk_bw_write_ensure_slice()

DUK_INTERNAL void duk_bw_write_ensure_slice	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	src_off,
		duk_size_t	len )

Definition at line 118 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                                         {
    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);
}

References DUK_ASSERT, DUK_BW_ENSURE, DUK_BW_GET_SIZE, duk_bw_write_raw_slice(), DUK_UNREF, and NULL.

duk_bw_write_raw_slice()

DUK_INTERNAL void duk_bw_write_raw_slice	(	duk_hthread *	thr,
		duk_bufwriter_ctx *	bw,
		duk_size_t	src_off,
		duk_size_t	len )

Definition at line 101 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                                                      {
    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;
}

References DUK_ASSERT, DUK_BW_GET_SIZE, DUK_MEMCPY, DUK_UNREF, NULL, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.

Referenced by duk_bw_write_ensure_slice().

duk_raw_read_double_be()

DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_raw_read_double_be

(

duk_uint8_t **

p

)

Definition at line 305 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                    {
    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;
}

References duk_double_union::d, DUK_MEMCPY, and duk_double_union::ui.

duk_raw_read_u16_be()

DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint16_t duk_raw_read_u16_be

(

duk_uint8_t **

p

)

Definition at line 281 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                 {
    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;
}

References DUK_MEMCPY.

duk_raw_read_u32_be()

DUK_INTERNAL DUK_ALWAYS_INLINE duk_uint32_t duk_raw_read_u32_be

(

duk_uint8_t **

p

)

Definition at line 293 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                 {
    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;
}

References DUK_MEMCPY.

duk_raw_write_double_be()

DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_double_be	(	duk_uint8_t **	p,
		duk_double_t	val )

Definition at line 345 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                               {
    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;
}

References duk_double_union::d, DUK_MEMCPY, and duk_double_union::ui.

duk_raw_write_u16_be()

DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u16_be	(	duk_uint8_t **	p,
		duk_uint16_t	val )

Definition at line 323 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                            {
    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;
}

References DUK_MEMCPY.

duk_raw_write_u32_be()

DUK_INTERNAL DUK_ALWAYS_INLINE void duk_raw_write_u32_be	(	duk_uint8_t **	p,
		duk_uint32_t	val )

Definition at line 334 of file duktape-1.5.2/src-separate/duk_util_bufwriter.c.

                                                                                            {
    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;
}

References DUK_MEMCPY.