Github User Fetcher 1.0.0
C Application with Server and GUI
Loading...
Searching...
No Matches
Data Structures | Macros | Functions | Variables
duk_util.h File Reference

Go to the source code of this file.

Data Structures

struct  duk_bitdecoder_ctx
 
struct  duk_bitencoder_ctx
 
struct  duk_bufwriter_ctx
 

Macros

#define DUK_UTIL_MIN_HASH_PRIME   17 /* must match genhashsizes.py */
 
#define DUK_UTIL_GET_HASH_PROBE_STEP(hash)   (duk_util_probe_steps[(hash) & 0x1f])
 
#define DUK_RAW_WRITE_U8(ptr, val)
 
#define DUK_RAW_WRITE_U16_BE(ptr, val)   duk_raw_write_u16_be(&(ptr), (duk_uint16_t) (val))
 
#define DUK_RAW_WRITE_U32_BE(ptr, val)   duk_raw_write_u32_be(&(ptr), (duk_uint32_t) (val))
 
#define DUK_RAW_WRITE_DOUBLE_BE(ptr, val)   duk_raw_write_double_be(&(ptr), (duk_double_t) (val))
 
#define DUK_RAW_WRITE_XUTF8(ptr, val)
 
#define DUK_RAW_WRITE_CESU8(ptr, val)
 
#define DUK_RAW_READ_U8(ptr)   ((duk_uint8_t) (*(ptr)++))
 
#define DUK_RAW_READ_U16_BE(ptr)   duk_raw_read_u16_be(&(ptr));
 
#define DUK_RAW_READ_U32_BE(ptr)   duk_raw_read_u32_be(&(ptr));
 
#define DUK_RAW_READ_DOUBLE_BE(ptr)   duk_raw_read_double_be(&(ptr));
 
#define DUK_BW_SPARE_ADD   64
 
#define DUK_BW_SPARE_SHIFT   4 /* 2^4 -> 1/16 = 6.25% spare */
 
#define DUK_BW_INIT_PUSHBUF(thr, bw_ctx, sz)
 
#define DUK_BW_INIT_WITHBUF(thr, bw_ctx, buf)
 
#define DUK_BW_COMPACT(thr, bw_ctx)
 
#define DUK_BW_PUSH_AS_STRING(thr, bw_ctx)
 
#define DUK_BW_ASSERT_VALID_EXPR(thr, bw_ctx)
 
#define DUK_BW_ASSERT_VALID(thr, bw_ctx)
 
#define DUK_BW_GET_PTR(thr, bw_ctx)    ((bw_ctx)->p)
 
#define DUK_BW_SET_PTR(thr, bw_ctx, ptr)
 
#define DUK_BW_ADD_PTR(thr, bw_ctx, delta)
 
#define DUK_BW_GET_BASEPTR(thr, bw_ctx)    ((bw_ctx)->p_base)
 
#define DUK_BW_GET_LIMITPTR(thr, bw_ctx)    ((bw_ctx)->p_limit)
 
#define DUK_BW_GET_SIZE(thr, bw_ctx)    ((duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base))
 
#define DUK_BW_SET_SIZE(thr, bw_ctx, sz)
 
#define DUK_BW_RESET_SIZE(thr, bw_ctx)
 
#define DUK_BW_GET_BUFFER(thr, bw_ctx)    ((bw_ctx)->buf)
 
#define DUK_BW_ENSURE(thr, bw_ctx, sz)
 
#define DUK_BW_ENSURE_RAW(thr, bw_ctx, sz, ptr)
 
#define DUK_BW_ENSURE_GETPTR(thr, bw_ctx, sz)    DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p)
 
#define DUK_BW_ASSERT_SPACE_EXPR(thr, bw_ctx, sz)
 
#define DUK_BW_ASSERT_SPACE(thr, bw_ctx, sz)
 
#define DUK_BW_SETPTR_AND_COMPACT(thr, bw_ctx, ptr)
 
#define DUK_BW_WRITE_RAW_U8(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_U8_2(thr, bw_ctx, val1, val2)
 
#define DUK_BW_WRITE_RAW_U8_3(thr, bw_ctx, val1, val2, val3)
 
#define DUK_BW_WRITE_RAW_U8_4(thr, bw_ctx, val1, val2, val3, val4)
 
#define DUK_BW_WRITE_RAW_U8_5(thr, bw_ctx, val1, val2, val3, val4, val5)
 
#define DUK_BW_WRITE_RAW_U8_6(thr, bw_ctx, val1, val2, val3, val4, val5, val6)
 
#define DUK_BW_WRITE_RAW_XUTF8(thr, bw_ctx, cp)
 
#define DUK_BW_WRITE_RAW_CESU8(thr, bw_ctx, cp)
 
#define DUK_BW_WRITE_RAW_BYTES(thr, bw_ctx, valptr, valsz)
 
#define DUK_BW_WRITE_RAW_CSTRING(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_HSTRING(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_HBUFFER(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_HBUFFER_FIXED(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_RAW_SLICE(thr, bw, dst_off, dst_len)    duk_bw_write_raw_slice((thr), (bw), (dst_off), (dst_len))
 
#define DUK_BW_INSERT_RAW_BYTES(thr, bw, dst_off, buf, len)    duk_bw_insert_raw_bytes((thr), (bw), (dst_off), (buf), (len))
 
#define DUK_BW_INSERT_RAW_SLICE(thr, bw, dst_off, src_off, len)    duk_bw_insert_raw_slice((thr), (bw), (dst_off), (src_off), (len))
 
#define DUK_BW_INSERT_RAW_AREA(thr, bw, off, len)    duk_bw_insert_raw_area((thr), (bw), (off), (len))
 
#define DUK_BW_REMOVE_RAW_SLICE(thr, bw, off, len)    duk_bw_remove_raw_slice((thr), (bw), (off), (len))
 
#define DUK_BW_WRITE_ENSURE_U8(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_U8_2(thr, bw_ctx, val1, val2)
 
#define DUK_BW_WRITE_ENSURE_U8_3(thr, bw_ctx, val1, val2, val3)
 
#define DUK_BW_WRITE_ENSURE_U8_4(thr, bw_ctx, val1, val2, val3, val4)
 
#define DUK_BW_WRITE_ENSURE_U8_5(thr, bw_ctx, val1, val2, val3, val4, val5)
 
#define DUK_BW_WRITE_ENSURE_U8_6(thr, bw_ctx, val1, val2, val3, val4, val5, val6)
 
#define DUK_BW_WRITE_ENSURE_XUTF8(thr, bw_ctx, cp)
 
#define DUK_BW_WRITE_ENSURE_CESU8(thr, bw_ctx, cp)
 
#define DUK_BW_WRITE_ENSURE_BYTES(thr, bw_ctx, valptr, valsz)
 
#define DUK_BW_WRITE_ENSURE_CSTRING(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_HSTRING(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_HBUFFER(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC(thr, bw_ctx, val)
 
#define DUK_BW_WRITE_ENSURE_SLICE(thr, bw, dst_off, dst_len)    duk_bw_write_ensure_slice((thr), (bw), (dst_off), (dst_len))
 
#define DUK_BW_INSERT_ENSURE_BYTES(thr, bw, dst_off, buf, len)    duk_bw_insert_ensure_bytes((thr), (bw), (dst_off), (buf), (len))
 
#define DUK_BW_INSERT_ENSURE_SLICE(thr, bw, dst_off, src_off, len)    duk_bw_insert_ensure_slice((thr), (bw), (dst_off), (src_off), (len))
 
#define DUK_BW_INSERT_ENSURE_AREA(thr, bw, off, len)
 
#define DUK_BW_REMOVE_ENSURE_SLICE(thr, bw, off, len)
 

Functions

DUK_INTERNAL_DECL duk_int32_t duk_bd_decode (duk_bitdecoder_ctx *ctx, duk_small_int_t bits)
 
DUK_INTERNAL_DECL duk_small_int_t duk_bd_decode_flag (duk_bitdecoder_ctx *ctx)
 
DUK_INTERNAL_DECL duk_int32_t duk_bd_decode_flagged (duk_bitdecoder_ctx *ctx, duk_small_int_t bits, duk_int32_t def_value)
 
DUK_INTERNAL_DECL void duk_be_encode (duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits)
 
DUK_INTERNAL_DECL void duk_be_finish (duk_bitencoder_ctx *ctx)
 
DUK_INTERNAL_DECL duk_uint32_t duk_util_tinyrandom_get_bits (duk_hthread *thr, duk_small_int_t n)
 
DUK_INTERNAL_DECL duk_double_t duk_util_tinyrandom_get_double (duk_hthread *thr)
 
DUK_INTERNAL_DECL void duk_bw_init (duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_hbuffer_dynamic *h_buf)
 
DUK_INTERNAL_DECL void duk_bw_init_pushbuf (duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t buf_size)
 
DUK_INTERNAL_DECL duk_uint8_t * duk_bw_resize (duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz)
 
DUK_INTERNAL_DECL void duk_bw_compact (duk_hthread *thr, duk_bufwriter_ctx *bw_ctx)
 
DUK_INTERNAL_DECL void duk_bw_write_raw_slice (duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len)
 
DUK_INTERNAL_DECL void duk_bw_write_ensure_slice (duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len)
 
DUK_INTERNAL_DECL 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_DECL 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_DECL 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_DECL 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_DECL 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_DECL 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_DECL void duk_bw_remove_raw_slice (duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len)
 
DUK_INTERNAL_DECL duk_uint16_t duk_raw_read_u16_be (duk_uint8_t **p)
 
DUK_INTERNAL_DECL duk_uint32_t duk_raw_read_u32_be (duk_uint8_t **p)
 
DUK_INTERNAL_DECL duk_double_t duk_raw_read_double_be (duk_uint8_t **p)
 
DUK_INTERNAL_DECL void duk_raw_write_u16_be (duk_uint8_t **p, duk_uint16_t val)
 
DUK_INTERNAL_DECL void duk_raw_write_u32_be (duk_uint8_t **p, duk_uint32_t val)
 
DUK_INTERNAL_DECL void duk_raw_write_double_be (duk_uint8_t **p, duk_double_t val)
 

Variables

DUK_INTERNAL_DECL const duk_uint8_t duk_lc_digits [36]
 
DUK_INTERNAL_DECL const duk_uint8_t duk_uc_nybbles [16]
 
DUK_INTERNAL_DECL const duk_int8_t duk_hex_dectab [256]
 

Macro Definition Documentation

◆ DUK_BW_ADD_PTR

#define DUK_BW_ADD_PTR ( thr,
bw_ctx,
delta )
Value:
do { \
(bw_ctx)->p += (delta); \
} while (0)

Definition at line 170 of file duktape-1.8.0/src-separate/duk_util.h.

170#define DUK_BW_ADD_PTR(thr,bw_ctx,delta) do { \
171 (bw_ctx)->p += (delta); \
172 } while (0)

◆ DUK_BW_ASSERT_SPACE

#define DUK_BW_ASSERT_SPACE ( thr,
bw_ctx,
sz )
Value:
do { \
DUK_BW_ASSERT_SPACE_EXPR((thr), (bw_ctx), (sz)); \
} while (0)

Definition at line 212 of file duktape-1.8.0/src-separate/duk_util.h.

212#define DUK_BW_ASSERT_SPACE(thr,bw_ctx,sz) do { \
213 DUK_BW_ASSERT_SPACE_EXPR((thr), (bw_ctx), (sz)); \
214 } while (0)

◆ DUK_BW_ASSERT_SPACE_EXPR

#define DUK_BW_ASSERT_SPACE_EXPR ( thr,
bw_ctx,
sz )
Value:
(DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)), \
DUK_ASSERT_EXPR((duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p) >= (duk_size_t) (sz)))
duk_size_t
size_t duk_size_t
Definition duktape-1.5.2/src-noline/duk_config.h:1770
DUK_BW_ASSERT_VALID_EXPR
#define DUK_BW_ASSERT_VALID_EXPR(thr, bw_ctx)
Definition duktape-1.8.0/src-separate/duk_util.h:149

Definition at line 209 of file duktape-1.8.0/src-separate/duk_util.h.

209#define DUK_BW_ASSERT_SPACE_EXPR(thr,bw_ctx,sz) \
210 (DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)), \
211 DUK_ASSERT_EXPR((duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p) >= (duk_size_t) (sz)))

◆ DUK_BW_ASSERT_VALID

#define DUK_BW_ASSERT_VALID ( thr,
bw_ctx )
Value:
do { \
DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)); \
} while (0)

Definition at line 159 of file duktape-1.8.0/src-separate/duk_util.h.

159#define DUK_BW_ASSERT_VALID(thr,bw_ctx) do { \
160 DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)); \
161 } while (0)

◆ DUK_BW_ASSERT_VALID_EXPR

#define DUK_BW_ASSERT_VALID_EXPR ( thr,
bw_ctx )
Value:
DUK_ASSERT_EXPR((bw_ctx) != NULL && \
(bw_ctx)->buf != NULL && \
((DUK_HBUFFER_DYNAMIC_GET_SIZE((bw_ctx)->buf) == 0) || \
((bw_ctx)->p != NULL && \
(bw_ctx)->p_base != NULL && \
(bw_ctx)->p_limit != NULL && \
(bw_ctx)->p_limit >= (bw_ctx)->p_base && \
(bw_ctx)->p >= (bw_ctx)->p_base && \
(bw_ctx)->p <= (bw_ctx)->p_limit)))
DUK_HBUFFER_DYNAMIC_GET_SIZE
#define DUK_HBUFFER_DYNAMIC_GET_SIZE(x)
Definition duktape-1.5.2/src-noline/duktape.c:6408
DUK_ASSERT_EXPR
#define DUK_ASSERT_EXPR(x)
Definition duktape-1.5.2/src-noline/duktape.c:7757
NULL
#define NULL
Definition gmacros.h:924

Definition at line 149 of file duktape-1.8.0/src-separate/duk_util.h.

149#define DUK_BW_ASSERT_VALID_EXPR(thr,bw_ctx) \
150 DUK_ASSERT_EXPR((bw_ctx) != NULL && \
151 (bw_ctx)->buf != NULL && \
152 ((DUK_HBUFFER_DYNAMIC_GET_SIZE((bw_ctx)->buf) == 0) || \
153 ((bw_ctx)->p != NULL && \
154 (bw_ctx)->p_base != NULL && \
155 (bw_ctx)->p_limit != NULL && \
156 (bw_ctx)->p_limit >= (bw_ctx)->p_base && \
157 (bw_ctx)->p >= (bw_ctx)->p_base && \
158 (bw_ctx)->p <= (bw_ctx)->p_limit)))

◆ DUK_BW_COMPACT

#define DUK_BW_COMPACT ( thr,
bw_ctx )
Value:
do { \
/* Make underlying buffer compact to match DUK_BW_GET_SIZE(). */ \
duk_bw_compact((thr), (bw_ctx)); \
} while (0)

Definition at line 135 of file duktape-1.8.0/src-separate/duk_util.h.

135#define DUK_BW_COMPACT(thr,bw_ctx) do { \
136 /* Make underlying buffer compact to match DUK_BW_GET_SIZE(). */ \
137 duk_bw_compact((thr), (bw_ctx)); \
138 } while (0)

◆ DUK_BW_ENSURE

#define DUK_BW_ENSURE ( thr,
bw_ctx,
sz )
Value:
do { \
duk_size_t duk__sz, duk__space; \
DUK_BW_ASSERT_VALID((thr), (bw_ctx)); \
duk__sz = (sz); \
duk__space = (duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p); \
if (duk__space < duk__sz) { \
(void) duk_bw_resize((thr), (bw_ctx), duk__sz); \
} \
} while (0)
duk_bw_resize
DUK_INTERNAL_DECL duk_uint8_t * duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz)
Definition duktape-1.5.2/src-noline/duktape.c:86124

Definition at line 192 of file duktape-1.8.0/src-separate/duk_util.h.

192#define DUK_BW_ENSURE(thr,bw_ctx,sz) do { \
193 duk_size_t duk__sz, duk__space; \
194 DUK_BW_ASSERT_VALID((thr), (bw_ctx)); \
195 duk__sz = (sz); \
196 duk__space = (duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p); \
197 if (duk__space < duk__sz) { \
198 (void) duk_bw_resize((thr), (bw_ctx), duk__sz); \
199 } \
200 } while (0)

◆ DUK_BW_ENSURE_GETPTR

#define DUK_BW_ENSURE_GETPTR ( thr,
bw_ctx,
sz )    DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p)

Definition at line 207 of file duktape-1.8.0/src-separate/duk_util.h.

207#define DUK_BW_ENSURE_GETPTR(thr,bw_ctx,sz) \
208 DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p)

◆ DUK_BW_ENSURE_RAW

#define DUK_BW_ENSURE_RAW ( thr,
bw_ctx,
sz,
ptr )
Value:
(((duk_size_t) ((bw_ctx)->p_limit - (ptr)) >= (sz)) ? \
(ptr) : \
((bw_ctx)->p = (ptr), duk_bw_resize((thr),(bw_ctx),(sz))))

Definition at line 203 of file duktape-1.8.0/src-separate/duk_util.h.

203#define DUK_BW_ENSURE_RAW(thr,bw_ctx,sz,ptr) \
204 (((duk_size_t) ((bw_ctx)->p_limit - (ptr)) >= (sz)) ? \
205 (ptr) : \
206 ((bw_ctx)->p = (ptr), duk_bw_resize((thr),(bw_ctx),(sz))))

◆ DUK_BW_GET_BASEPTR

#define DUK_BW_GET_BASEPTR ( thr,
bw_ctx )    ((bw_ctx)->p_base)

Definition at line 173 of file duktape-1.8.0/src-separate/duk_util.h.

173#define DUK_BW_GET_BASEPTR(thr,bw_ctx) \
174 ((bw_ctx)->p_base)

◆ DUK_BW_GET_BUFFER

#define DUK_BW_GET_BUFFER ( thr,
bw_ctx )    ((bw_ctx)->buf)

Definition at line 187 of file duktape-1.8.0/src-separate/duk_util.h.

187#define DUK_BW_GET_BUFFER(thr,bw_ctx) \
188 ((bw_ctx)->buf)

◆ DUK_BW_GET_LIMITPTR

#define DUK_BW_GET_LIMITPTR ( thr,
bw_ctx )    ((bw_ctx)->p_limit)

Definition at line 175 of file duktape-1.8.0/src-separate/duk_util.h.

175#define DUK_BW_GET_LIMITPTR(thr,bw_ctx) \
176 ((bw_ctx)->p_limit)

◆ DUK_BW_GET_PTR

#define DUK_BW_GET_PTR ( thr,
bw_ctx )    ((bw_ctx)->p)

Definition at line 165 of file duktape-1.8.0/src-separate/duk_util.h.

165#define DUK_BW_GET_PTR(thr,bw_ctx) \
166 ((bw_ctx)->p)

◆ DUK_BW_GET_SIZE

#define DUK_BW_GET_SIZE ( thr,
bw_ctx )    ((duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base))

Definition at line 177 of file duktape-1.8.0/src-separate/duk_util.h.

177#define DUK_BW_GET_SIZE(thr,bw_ctx) \
178 ((duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base))

◆ DUK_BW_INIT_PUSHBUF

#define DUK_BW_INIT_PUSHBUF ( thr,
bw_ctx,
sz )
Value:
do { \
duk_bw_init_pushbuf((thr), (bw_ctx), (sz)); \
} while (0)

Definition at line 129 of file duktape-1.8.0/src-separate/duk_util.h.

129#define DUK_BW_INIT_PUSHBUF(thr,bw_ctx,sz) do { \
130 duk_bw_init_pushbuf((thr), (bw_ctx), (sz)); \
131 } while (0)

◆ DUK_BW_INIT_WITHBUF

#define DUK_BW_INIT_WITHBUF ( thr,
bw_ctx,
buf )
Value:
do { \
duk_bw_init((thr), (bw_ctx), (buf)); \
} while (0)

Definition at line 132 of file duktape-1.8.0/src-separate/duk_util.h.

132#define DUK_BW_INIT_WITHBUF(thr,bw_ctx,buf) do { \
133 duk_bw_init((thr), (bw_ctx), (buf)); \
134 } while (0)

◆ DUK_BW_INSERT_ENSURE_AREA

#define DUK_BW_INSERT_ENSURE_AREA ( thr,
bw,
off,
len )
Value:
/* Evaluates to (duk_uint8_t *) pointing to start of area. */ \
duk_bw_insert_ensure_area((thr), (bw), (off), (len))

Definition at line 454 of file duktape-1.8.0/src-separate/duk_util.h.

454#define DUK_BW_INSERT_ENSURE_AREA(thr,bw,off,len) \
455 /* Evaluates to (duk_uint8_t *) pointing to start of area. */ \
456 duk_bw_insert_ensure_area((thr), (bw), (off), (len))

◆ DUK_BW_INSERT_ENSURE_BYTES

#define DUK_BW_INSERT_ENSURE_BYTES ( thr,
bw,
dst_off,
buf,
len )    duk_bw_insert_ensure_bytes((thr), (bw), (dst_off), (buf), (len))

Definition at line 450 of file duktape-1.8.0/src-separate/duk_util.h.

450#define DUK_BW_INSERT_ENSURE_BYTES(thr,bw,dst_off,buf,len) \
451 duk_bw_insert_ensure_bytes((thr), (bw), (dst_off), (buf), (len))

◆ DUK_BW_INSERT_ENSURE_SLICE

#define DUK_BW_INSERT_ENSURE_SLICE ( thr,
bw,
dst_off,
src_off,
len )    duk_bw_insert_ensure_slice((thr), (bw), (dst_off), (src_off), (len))

Definition at line 452 of file duktape-1.8.0/src-separate/duk_util.h.

452#define DUK_BW_INSERT_ENSURE_SLICE(thr,bw,dst_off,src_off,len) \
453 duk_bw_insert_ensure_slice((thr), (bw), (dst_off), (src_off), (len))

◆ DUK_BW_INSERT_RAW_AREA

#define DUK_BW_INSERT_RAW_AREA ( thr,
bw,
off,
len )    duk_bw_insert_raw_area((thr), (bw), (off), (len))

Definition at line 359 of file duktape-1.8.0/src-separate/duk_util.h.

359#define DUK_BW_INSERT_RAW_AREA(thr,bw,off,len) \
360 duk_bw_insert_raw_area((thr), (bw), (off), (len))

◆ DUK_BW_INSERT_RAW_BYTES

#define DUK_BW_INSERT_RAW_BYTES ( thr,
bw,
dst_off,
buf,
len )    duk_bw_insert_raw_bytes((thr), (bw), (dst_off), (buf), (len))

Definition at line 346 of file duktape-1.8.0/src-separate/duk_util.h.

346#define DUK_BW_INSERT_RAW_BYTES(thr,bw,dst_off,buf,len) \
347 duk_bw_insert_raw_bytes((thr), (bw), (dst_off), (buf), (len))

◆ DUK_BW_INSERT_RAW_SLICE

#define DUK_BW_INSERT_RAW_SLICE ( thr,
bw,
dst_off,
src_off,
len )    duk_bw_insert_raw_slice((thr), (bw), (dst_off), (src_off), (len))

Definition at line 352 of file duktape-1.8.0/src-separate/duk_util.h.

352#define DUK_BW_INSERT_RAW_SLICE(thr,bw,dst_off,src_off,len) \
353 duk_bw_insert_raw_slice((thr), (bw), (dst_off), (src_off), (len))

◆ DUK_BW_PUSH_AS_STRING

#define DUK_BW_PUSH_AS_STRING ( thr,
bw_ctx )
Value:
do { \
duk_push_lstring((duk_context *) (thr), \
(const char *) (bw_ctx)->p_base, \
(duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
} while (0)
duk_hthread
Definition duktape-1.5.2/src-noline/duktape.c:6190

Definition at line 139 of file duktape-1.8.0/src-separate/duk_util.h.

139#define DUK_BW_PUSH_AS_STRING(thr,bw_ctx) do { \
140 duk_push_lstring((duk_context *) (thr), \
141 (const char *) (bw_ctx)->p_base, \
142 (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
143 } while (0)

◆ DUK_BW_REMOVE_ENSURE_SLICE

#define DUK_BW_REMOVE_ENSURE_SLICE ( thr,
bw,
off,
len )
Value:
/* No difference between raw/ensure because the buffer shrinks. */ \
DUK_BW_REMOVE_RAW_SLICE((thr), (bw), (off), (len))

Definition at line 457 of file duktape-1.8.0/src-separate/duk_util.h.

457#define DUK_BW_REMOVE_ENSURE_SLICE(thr,bw,off,len) \
458 /* No difference between raw/ensure because the buffer shrinks. */ \
459 DUK_BW_REMOVE_RAW_SLICE((thr), (bw), (off), (len))

◆ DUK_BW_REMOVE_RAW_SLICE

#define DUK_BW_REMOVE_RAW_SLICE ( thr,
bw,
off,
len )    duk_bw_remove_raw_slice((thr), (bw), (off), (len))

Definition at line 363 of file duktape-1.8.0/src-separate/duk_util.h.

363#define DUK_BW_REMOVE_RAW_SLICE(thr,bw,off,len) \
364 duk_bw_remove_raw_slice((thr), (bw), (off), (len))

◆ DUK_BW_RESET_SIZE

#define DUK_BW_RESET_SIZE ( thr,
bw_ctx )
Value:
do { \
/* Reset to zero size, keep current limit. */ \
(bw_ctx)->p = (bw_ctx)->p_base; \
} while (0)

Definition at line 183 of file duktape-1.8.0/src-separate/duk_util.h.

183#define DUK_BW_RESET_SIZE(thr,bw_ctx) do { \
184 /* Reset to zero size, keep current limit. */ \
185 (bw_ctx)->p = (bw_ctx)->p_base; \
186 } while (0)

◆ DUK_BW_SET_PTR

#define DUK_BW_SET_PTR ( thr,
bw_ctx,
ptr )
Value:
do { \
(bw_ctx)->p = (ptr); \
} while (0)

Definition at line 167 of file duktape-1.8.0/src-separate/duk_util.h.

167#define DUK_BW_SET_PTR(thr,bw_ctx,ptr) do { \
168 (bw_ctx)->p = (ptr); \
169 } while (0)

◆ DUK_BW_SET_SIZE

#define DUK_BW_SET_SIZE ( thr,
bw_ctx,
sz )
Value:
do { \
DUK_ASSERT((duk_size_t) (sz) <= (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
(bw_ctx)->p = (bw_ctx)->p_base + (sz); \
} while (0)

Definition at line 179 of file duktape-1.8.0/src-separate/duk_util.h.

179#define DUK_BW_SET_SIZE(thr,bw_ctx,sz) do { \
180 DUK_ASSERT((duk_size_t) (sz) <= (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
181 (bw_ctx)->p = (bw_ctx)->p_base + (sz); \
182 } while (0)

◆ DUK_BW_SETPTR_AND_COMPACT

#define DUK_BW_SETPTR_AND_COMPACT ( thr,
bw_ctx,
ptr )
Value:
do { \
(bw_ctx)->p = (ptr); \
duk_bw_compact((thr), (bw_ctx)); \
} while (0)

Definition at line 218 of file duktape-1.8.0/src-separate/duk_util.h.

218#define DUK_BW_SETPTR_AND_COMPACT(thr,bw_ctx,ptr) do { \
219 (bw_ctx)->p = (ptr); \
220 duk_bw_compact((thr), (bw_ctx)); \
221 } while (0)

◆ DUK_BW_SPARE_ADD

#define DUK_BW_SPARE_ADD   64

Definition at line 124 of file duktape-1.8.0/src-separate/duk_util.h.

◆ DUK_BW_SPARE_SHIFT

#define DUK_BW_SPARE_SHIFT   4 /* 2^4 -> 1/16 = 6.25% spare */

Definition at line 125 of file duktape-1.8.0/src-separate/duk_util.h.

◆ DUK_BW_WRITE_ENSURE_BYTES

#define DUK_BW_WRITE_ENSURE_BYTES ( thr,
bw_ctx,
valptr,
valsz )
Value:
do { \
const void *duk__valptr; \
duk_size_t duk__valsz; \
duk__valptr = (const void *) (valptr); \
duk__valsz = (duk_size_t) (valsz); \
DUK_BW_ENSURE((thr), (bw_ctx), duk__valsz); \
DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
(bw_ctx)->p += duk__valsz; \
} while (0)

Definition at line 401 of file duktape-1.8.0/src-separate/duk_util.h.

401#define DUK_BW_WRITE_ENSURE_BYTES(thr,bw_ctx,valptr,valsz) do { \
402 const void *duk__valptr; \
403 duk_size_t duk__valsz; \
404 duk__valptr = (const void *) (valptr); \
405 duk__valsz = (duk_size_t) (valsz); \
406 DUK_BW_ENSURE((thr), (bw_ctx), duk__valsz); \
407 DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
408 (bw_ctx)->p += duk__valsz; \
409 } while (0)

◆ DUK_BW_WRITE_ENSURE_CESU8

#define DUK_BW_WRITE_ENSURE_CESU8 ( thr,
bw_ctx,
cp )
Value:
do { \
DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_CESU8_LENGTH); \
DUK_BW_WRITE_RAW_CESU8((thr), (bw_ctx), (cp)); \
} while (0)
DUK_UNICODE_MAX_CESU8_LENGTH
#define DUK_UNICODE_MAX_CESU8_LENGTH
Definition duktape-1.5.2/src-noline/duktape.c:8013

Definition at line 396 of file duktape-1.8.0/src-separate/duk_util.h.

396#define DUK_BW_WRITE_ENSURE_CESU8(thr,bw_ctx,cp) do { \
397 DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_CESU8_LENGTH); \
398 DUK_BW_WRITE_RAW_CESU8((thr), (bw_ctx), (cp)); \
399 } while (0)

◆ DUK_BW_WRITE_ENSURE_CSTRING

#define DUK_BW_WRITE_ENSURE_CSTRING ( thr,
bw_ctx,
val )
Value:
do { \
const duk_uint8_t *duk__val; \
duk_size_t duk__val_len; \
duk__val = (const duk_uint8_t *) (val); \
duk__val_len = DUK_STRLEN((const char *) duk__val); \
DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
(bw_ctx)->p += duk__val_len; \
} while (0)
DUK_STRLEN
#define DUK_STRLEN
Definition duktape-1.5.2/src-noline/duk_config.h:1997

Definition at line 410 of file duktape-1.8.0/src-separate/duk_util.h.

410#define DUK_BW_WRITE_ENSURE_CSTRING(thr,bw_ctx,val) do { \
411 const duk_uint8_t *duk__val; \
412 duk_size_t duk__val_len; \
413 duk__val = (const duk_uint8_t *) (val); \
414 duk__val_len = DUK_STRLEN((const char *) duk__val); \
415 DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
416 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
417 (bw_ctx)->p += duk__val_len; \
418 } while (0)

◆ DUK_BW_WRITE_ENSURE_HBUFFER

#define DUK_BW_WRITE_ENSURE_HBUFFER ( thr,
bw_ctx,
val )
Value:
do { \
duk_size_t duk__val_len; \
duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
(bw_ctx)->p += duk__val_len; \
} while (0)
DUK_HBUFFER_GET_DATA_PTR
#define DUK_HBUFFER_GET_DATA_PTR(heap, x)
Definition duktape-1.5.2/src-noline/duktape.c:6477
DUK_HBUFFER_GET_SIZE
#define DUK_HBUFFER_GET_SIZE(x)
Definition duktape-1.5.2/src-noline/duktape.c:6393

Definition at line 426 of file duktape-1.8.0/src-separate/duk_util.h.

426#define DUK_BW_WRITE_ENSURE_HBUFFER(thr,bw_ctx,val) do { \
427 duk_size_t duk__val_len; \
428 duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
429 DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
430 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
431 (bw_ctx)->p += duk__val_len; \
432 } while (0)

◆ DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC

#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC ( thr,
bw_ctx,
val )
Value:
do { \
duk_size_t duk__val_len; \
duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
(bw_ctx)->p += duk__val_len; \
} while (0)
DUK_HBUFFER_DYNAMIC_GET_DATA_PTR
#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, x)
Definition duktape-1.5.2/src-noline/duktape.c:6428

Definition at line 440 of file duktape-1.8.0/src-separate/duk_util.h.

440#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \
441 duk_size_t duk__val_len; \
442 duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
443 DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
444 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
445 (bw_ctx)->p += duk__val_len; \
446 } while (0)

◆ DUK_BW_WRITE_ENSURE_HBUFFER_FIXED

#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED ( thr,
bw_ctx,
val )
Value:
do { \
duk_size_t duk__val_len; \
duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
(bw_ctx)->p += duk__val_len; \
} while (0)
DUK_HBUFFER_FIXED_GET_SIZE
#define DUK_HBUFFER_FIXED_GET_SIZE(x)
Definition duktape-1.5.2/src-noline/duktape.c:6405
DUK_HBUFFER_FIXED_GET_DATA_PTR
#define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap, x)
Definition duktape-1.5.2/src-noline/duktape.c:6416

Definition at line 433 of file duktape-1.8.0/src-separate/duk_util.h.

433#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED(thr,bw_ctx,val) do { \
434 duk_size_t duk__val_len; \
435 duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
436 DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
437 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
438 (bw_ctx)->p += duk__val_len; \
439 } while (0)

◆ DUK_BW_WRITE_ENSURE_HSTRING

#define DUK_BW_WRITE_ENSURE_HSTRING ( thr,
bw_ctx,
val )
Value:
do { \
duk_size_t duk__val_len; \
duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
(bw_ctx)->p += duk__val_len; \
} while (0)
DUK_HSTRING_GET_DATA
#define DUK_HSTRING_GET_DATA(x)
Definition duktape-1.5.2/src-noline/duktape.c:4522
DUK_HSTRING_GET_BYTELEN
#define DUK_HSTRING_GET_BYTELEN(x)
Definition duktape-1.5.2/src-noline/duktape.c:4505

Definition at line 419 of file duktape-1.8.0/src-separate/duk_util.h.

419#define DUK_BW_WRITE_ENSURE_HSTRING(thr,bw_ctx,val) do { \
420 duk_size_t duk__val_len; \
421 duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
422 DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
423 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
424 (bw_ctx)->p += duk__val_len; \
425 } while (0)

◆ DUK_BW_WRITE_ENSURE_SLICE

#define DUK_BW_WRITE_ENSURE_SLICE ( thr,
bw,
dst_off,
dst_len )    duk_bw_write_ensure_slice((thr), (bw), (dst_off), (dst_len))

Definition at line 448 of file duktape-1.8.0/src-separate/duk_util.h.

448#define DUK_BW_WRITE_ENSURE_SLICE(thr,bw,dst_off,dst_len) \
449 duk_bw_write_ensure_slice((thr), (bw), (dst_off), (dst_len))

◆ DUK_BW_WRITE_ENSURE_U8

#define DUK_BW_WRITE_ENSURE_U8 ( thr,
bw_ctx,
val )
Value:
do { \
DUK_BW_ENSURE((thr), (bw_ctx), 1); \
DUK_BW_WRITE_RAW_U8((thr), (bw_ctx), (val)); \
} while (0)

Definition at line 368 of file duktape-1.8.0/src-separate/duk_util.h.

368#define DUK_BW_WRITE_ENSURE_U8(thr,bw_ctx,val) do { \
369 DUK_BW_ENSURE((thr), (bw_ctx), 1); \
370 DUK_BW_WRITE_RAW_U8((thr), (bw_ctx), (val)); \
371 } while (0)

◆ DUK_BW_WRITE_ENSURE_U8_2

#define DUK_BW_WRITE_ENSURE_U8_2 ( thr,
bw_ctx,
val1,
val2 )
Value:
do { \
DUK_BW_ENSURE((thr), (bw_ctx), 2); \
DUK_BW_WRITE_RAW_U8_2((thr), (bw_ctx), (val1), (val2)); \
} while (0)

Definition at line 372 of file duktape-1.8.0/src-separate/duk_util.h.

372#define DUK_BW_WRITE_ENSURE_U8_2(thr,bw_ctx,val1,val2) do { \
373 DUK_BW_ENSURE((thr), (bw_ctx), 2); \
374 DUK_BW_WRITE_RAW_U8_2((thr), (bw_ctx), (val1), (val2)); \
375 } while (0)

◆ DUK_BW_WRITE_ENSURE_U8_3

#define DUK_BW_WRITE_ENSURE_U8_3 ( thr,
bw_ctx,
val1,
val2,
val3 )
Value:
do { \
DUK_BW_ENSURE((thr), (bw_ctx), 3); \
DUK_BW_WRITE_RAW_U8_3((thr), (bw_ctx), (val1), (val2), (val3)); \
} while (0)

Definition at line 376 of file duktape-1.8.0/src-separate/duk_util.h.

376#define DUK_BW_WRITE_ENSURE_U8_3(thr,bw_ctx,val1,val2,val3) do { \
377 DUK_BW_ENSURE((thr), (bw_ctx), 3); \
378 DUK_BW_WRITE_RAW_U8_3((thr), (bw_ctx), (val1), (val2), (val3)); \
379 } while (0)

◆ DUK_BW_WRITE_ENSURE_U8_4

#define DUK_BW_WRITE_ENSURE_U8_4 ( thr,
bw_ctx,
val1,
val2,
val3,
val4 )
Value:
do { \
DUK_BW_ENSURE((thr), (bw_ctx), 4); \
DUK_BW_WRITE_RAW_U8_4((thr), (bw_ctx), (val1), (val2), (val3), (val4)); \
} while (0)

Definition at line 380 of file duktape-1.8.0/src-separate/duk_util.h.

380#define DUK_BW_WRITE_ENSURE_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \
381 DUK_BW_ENSURE((thr), (bw_ctx), 4); \
382 DUK_BW_WRITE_RAW_U8_4((thr), (bw_ctx), (val1), (val2), (val3), (val4)); \
383 } while (0)

◆ DUK_BW_WRITE_ENSURE_U8_5

#define DUK_BW_WRITE_ENSURE_U8_5 ( thr,
bw_ctx,
val1,
val2,
val3,
val4,
val5 )
Value:
do { \
DUK_BW_ENSURE((thr), (bw_ctx), 5); \
DUK_BW_WRITE_RAW_U8_5((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5)); \
} while (0)

Definition at line 384 of file duktape-1.8.0/src-separate/duk_util.h.

384#define DUK_BW_WRITE_ENSURE_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \
385 DUK_BW_ENSURE((thr), (bw_ctx), 5); \
386 DUK_BW_WRITE_RAW_U8_5((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5)); \
387 } while (0)

◆ DUK_BW_WRITE_ENSURE_U8_6

#define DUK_BW_WRITE_ENSURE_U8_6 ( thr,
bw_ctx,
val1,
val2,
val3,
val4,
val5,
val6 )
Value:
do { \
DUK_BW_ENSURE((thr), (bw_ctx), 6); \
DUK_BW_WRITE_RAW_U8_6((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5), (val6)); \
} while (0)

Definition at line 388 of file duktape-1.8.0/src-separate/duk_util.h.

388#define DUK_BW_WRITE_ENSURE_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \
389 DUK_BW_ENSURE((thr), (bw_ctx), 6); \
390 DUK_BW_WRITE_RAW_U8_6((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5), (val6)); \
391 } while (0)

◆ DUK_BW_WRITE_ENSURE_XUTF8

#define DUK_BW_WRITE_ENSURE_XUTF8 ( thr,
bw_ctx,
cp )
Value:
do { \
DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_XUTF8_LENGTH); \
DUK_BW_WRITE_RAW_XUTF8((thr), (bw_ctx), (cp)); \
} while (0)
DUK_UNICODE_MAX_XUTF8_LENGTH
#define DUK_UNICODE_MAX_XUTF8_LENGTH
Definition duktape-1.5.2/src-noline/duktape.c:8011

Definition at line 392 of file duktape-1.8.0/src-separate/duk_util.h.

392#define DUK_BW_WRITE_ENSURE_XUTF8(thr,bw_ctx,cp) do { \
393 DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_XUTF8_LENGTH); \
394 DUK_BW_WRITE_RAW_XUTF8((thr), (bw_ctx), (cp)); \
395 } while (0)

◆ DUK_BW_WRITE_RAW_BYTES

#define DUK_BW_WRITE_RAW_BYTES ( thr,
bw_ctx,
valptr,
valsz )
Value:
do { \
const void *duk__valptr; \
duk_size_t duk__valsz; \
duk__valptr = (const void *) (valptr); \
duk__valsz = (duk_size_t) (valsz); \
DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
(bw_ctx)->p += duk__valsz; \
} while (0)

Definition at line 300 of file duktape-1.8.0/src-separate/duk_util.h.

300#define DUK_BW_WRITE_RAW_BYTES(thr,bw_ctx,valptr,valsz) do { \
301 const void *duk__valptr; \
302 duk_size_t duk__valsz; \
303 duk__valptr = (const void *) (valptr); \
304 duk__valsz = (duk_size_t) (valsz); \
305 DUK_MEMCPY((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
306 (bw_ctx)->p += duk__valsz; \
307 } while (0)

◆ DUK_BW_WRITE_RAW_CESU8

#define DUK_BW_WRITE_RAW_CESU8 ( thr,
bw_ctx,
cp )
Value:
do { \
duk_ucodepoint_t duk__cp; \
duk_small_int_t duk__enc_len; \
duk__cp = (duk_ucodepoint_t) (cp); \
DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_cesu8_length(duk__cp)); \
duk__enc_len = duk_unicode_encode_cesu8(duk__cp, (bw_ctx)->p); \
(bw_ctx)->p += duk__enc_len; \
} while (0)
duk_small_int_t
int duk_small_int_t
Definition duktape-1.5.2/src-noline/duk_config.h:1807
duk_ucodepoint_t
duk_uint_t duk_ucodepoint_t
Definition duktape-1.5.2/src-noline/duk_config.h:1869
duk_unicode_encode_cesu8
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_cesu8(duk_ucodepoint_t cp, duk_uint8_t *out)
Definition duktape-1.5.2/src-noline/duktape.c:10009

Definition at line 291 of file duktape-1.8.0/src-separate/duk_util.h.

291#define DUK_BW_WRITE_RAW_CESU8(thr,bw_ctx,cp) do { \
292 duk_ucodepoint_t duk__cp; \
293 duk_small_int_t duk__enc_len; \
294 duk__cp = (duk_ucodepoint_t) (cp); \
295 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_cesu8_length(duk__cp)); \
296 duk__enc_len = duk_unicode_encode_cesu8(duk__cp, (bw_ctx)->p); \
297 (bw_ctx)->p += duk__enc_len; \
298 } while (0)

◆ DUK_BW_WRITE_RAW_CSTRING

#define DUK_BW_WRITE_RAW_CSTRING ( thr,
bw_ctx,
val )
Value:
do { \
const duk_uint8_t *duk__val; \
duk_size_t duk__val_len; \
duk__val = (const duk_uint8_t *) (val); \
duk__val_len = DUK_STRLEN((const char *) duk__val); \
DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
(bw_ctx)->p += duk__val_len; \
} while (0)

Definition at line 308 of file duktape-1.8.0/src-separate/duk_util.h.

308#define DUK_BW_WRITE_RAW_CSTRING(thr,bw_ctx,val) do { \
309 const duk_uint8_t *duk__val; \
310 duk_size_t duk__val_len; \
311 duk__val = (const duk_uint8_t *) (val); \
312 duk__val_len = DUK_STRLEN((const char *) duk__val); \
313 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
314 (bw_ctx)->p += duk__val_len; \
315 } while (0)

◆ DUK_BW_WRITE_RAW_HBUFFER

#define DUK_BW_WRITE_RAW_HBUFFER ( thr,
bw_ctx,
val )
Value:
do { \
duk_size_t duk__val_len; \
duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
(bw_ctx)->p += duk__val_len; \
} while (0)

Definition at line 322 of file duktape-1.8.0/src-separate/duk_util.h.

322#define DUK_BW_WRITE_RAW_HBUFFER(thr,bw_ctx,val) do { \
323 duk_size_t duk__val_len; \
324 duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
325 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
326 (bw_ctx)->p += duk__val_len; \
327 } while (0)

◆ DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC

#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC ( thr,
bw_ctx,
val )
Value:
do { \
duk_size_t duk__val_len; \
duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
(bw_ctx)->p += duk__val_len; \
} while (0)

Definition at line 334 of file duktape-1.8.0/src-separate/duk_util.h.

334#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \
335 duk_size_t duk__val_len; \
336 duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
337 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
338 (bw_ctx)->p += duk__val_len; \
339 } while (0)

◆ DUK_BW_WRITE_RAW_HBUFFER_FIXED

#define DUK_BW_WRITE_RAW_HBUFFER_FIXED ( thr,
bw_ctx,
val )
Value:
do { \
duk_size_t duk__val_len; \
duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
(bw_ctx)->p += duk__val_len; \
} while (0)

Definition at line 328 of file duktape-1.8.0/src-separate/duk_util.h.

328#define DUK_BW_WRITE_RAW_HBUFFER_FIXED(thr,bw_ctx,val) do { \
329 duk_size_t duk__val_len; \
330 duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
331 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
332 (bw_ctx)->p += duk__val_len; \
333 } while (0)

◆ DUK_BW_WRITE_RAW_HSTRING

#define DUK_BW_WRITE_RAW_HSTRING ( thr,
bw_ctx,
val )
Value:
do { \
duk_size_t duk__val_len; \
duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
(bw_ctx)->p += duk__val_len; \
} while (0)

Definition at line 316 of file duktape-1.8.0/src-separate/duk_util.h.

316#define DUK_BW_WRITE_RAW_HSTRING(thr,bw_ctx,val) do { \
317 duk_size_t duk__val_len; \
318 duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
319 DUK_MEMCPY((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
320 (bw_ctx)->p += duk__val_len; \
321 } while (0)

◆ DUK_BW_WRITE_RAW_SLICE

#define DUK_BW_WRITE_RAW_SLICE ( thr,
bw,
dst_off,
dst_len )    duk_bw_write_raw_slice((thr), (bw), (dst_off), (dst_len))

Definition at line 342 of file duktape-1.8.0/src-separate/duk_util.h.

342#define DUK_BW_WRITE_RAW_SLICE(thr,bw,dst_off,dst_len) \
343 duk_bw_write_raw_slice((thr), (bw), (dst_off), (dst_len))

◆ DUK_BW_WRITE_RAW_U8

#define DUK_BW_WRITE_RAW_U8 ( thr,
bw_ctx,
val )
Value:
do { \
DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 1); \
*(bw_ctx)->p++ = (duk_uint8_t) (val); \
} while (0)

Definition at line 229 of file duktape-1.8.0/src-separate/duk_util.h.

229#define DUK_BW_WRITE_RAW_U8(thr,bw_ctx,val) do { \
230 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 1); \
231 *(bw_ctx)->p++ = (duk_uint8_t) (val); \
232 } while (0)

◆ DUK_BW_WRITE_RAW_U8_2

#define DUK_BW_WRITE_RAW_U8_2 ( thr,
bw_ctx,
val1,
val2 )
Value:
do { \
duk_uint8_t *duk__p; \
DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 2); \
duk__p = (bw_ctx)->p; \
*duk__p++ = (duk_uint8_t) (val1); \
*duk__p++ = (duk_uint8_t) (val2); \
(bw_ctx)->p = duk__p; \
} while (0)

Definition at line 233 of file duktape-1.8.0/src-separate/duk_util.h.

233#define DUK_BW_WRITE_RAW_U8_2(thr,bw_ctx,val1,val2) do { \
234 duk_uint8_t *duk__p; \
235 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 2); \
236 duk__p = (bw_ctx)->p; \
237 *duk__p++ = (duk_uint8_t) (val1); \
238 *duk__p++ = (duk_uint8_t) (val2); \
239 (bw_ctx)->p = duk__p; \
240 } while (0)

◆ DUK_BW_WRITE_RAW_U8_3

#define DUK_BW_WRITE_RAW_U8_3 ( thr,
bw_ctx,
val1,
val2,
val3 )
Value:
do { \
duk_uint8_t *duk__p; \
DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 3); \
duk__p = (bw_ctx)->p; \
*duk__p++ = (duk_uint8_t) (val1); \
*duk__p++ = (duk_uint8_t) (val2); \
*duk__p++ = (duk_uint8_t) (val3); \
(bw_ctx)->p = duk__p; \
} while (0)

Definition at line 241 of file duktape-1.8.0/src-separate/duk_util.h.

241#define DUK_BW_WRITE_RAW_U8_3(thr,bw_ctx,val1,val2,val3) do { \
242 duk_uint8_t *duk__p; \
243 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 3); \
244 duk__p = (bw_ctx)->p; \
245 *duk__p++ = (duk_uint8_t) (val1); \
246 *duk__p++ = (duk_uint8_t) (val2); \
247 *duk__p++ = (duk_uint8_t) (val3); \
248 (bw_ctx)->p = duk__p; \
249 } while (0)

◆ DUK_BW_WRITE_RAW_U8_4

#define DUK_BW_WRITE_RAW_U8_4 ( thr,
bw_ctx,
val1,
val2,
val3,
val4 )
Value:
do { \
duk_uint8_t *duk__p; \
DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 4); \
duk__p = (bw_ctx)->p; \
*duk__p++ = (duk_uint8_t) (val1); \
*duk__p++ = (duk_uint8_t) (val2); \
*duk__p++ = (duk_uint8_t) (val3); \
*duk__p++ = (duk_uint8_t) (val4); \
(bw_ctx)->p = duk__p; \
} while (0)

Definition at line 250 of file duktape-1.8.0/src-separate/duk_util.h.

250#define DUK_BW_WRITE_RAW_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \
251 duk_uint8_t *duk__p; \
252 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 4); \
253 duk__p = (bw_ctx)->p; \
254 *duk__p++ = (duk_uint8_t) (val1); \
255 *duk__p++ = (duk_uint8_t) (val2); \
256 *duk__p++ = (duk_uint8_t) (val3); \
257 *duk__p++ = (duk_uint8_t) (val4); \
258 (bw_ctx)->p = duk__p; \
259 } while (0)

◆ DUK_BW_WRITE_RAW_U8_5

#define DUK_BW_WRITE_RAW_U8_5 ( thr,
bw_ctx,
val1,
val2,
val3,
val4,
val5 )
Value:
do { \
duk_uint8_t *duk__p; \
DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 5); \
duk__p = (bw_ctx)->p; \
*duk__p++ = (duk_uint8_t) (val1); \
*duk__p++ = (duk_uint8_t) (val2); \
*duk__p++ = (duk_uint8_t) (val3); \
*duk__p++ = (duk_uint8_t) (val4); \
*duk__p++ = (duk_uint8_t) (val5); \
(bw_ctx)->p = duk__p; \
} while (0)

Definition at line 260 of file duktape-1.8.0/src-separate/duk_util.h.

260#define DUK_BW_WRITE_RAW_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \
261 duk_uint8_t *duk__p; \
262 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 5); \
263 duk__p = (bw_ctx)->p; \
264 *duk__p++ = (duk_uint8_t) (val1); \
265 *duk__p++ = (duk_uint8_t) (val2); \
266 *duk__p++ = (duk_uint8_t) (val3); \
267 *duk__p++ = (duk_uint8_t) (val4); \
268 *duk__p++ = (duk_uint8_t) (val5); \
269 (bw_ctx)->p = duk__p; \
270 } while (0)

◆ DUK_BW_WRITE_RAW_U8_6

#define DUK_BW_WRITE_RAW_U8_6 ( thr,
bw_ctx,
val1,
val2,
val3,
val4,
val5,
val6 )
Value:
do { \
duk_uint8_t *duk__p; \
DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 6); \
duk__p = (bw_ctx)->p; \
*duk__p++ = (duk_uint8_t) (val1); \
*duk__p++ = (duk_uint8_t) (val2); \
*duk__p++ = (duk_uint8_t) (val3); \
*duk__p++ = (duk_uint8_t) (val4); \
*duk__p++ = (duk_uint8_t) (val5); \
*duk__p++ = (duk_uint8_t) (val6); \
(bw_ctx)->p = duk__p; \
} while (0)

Definition at line 271 of file duktape-1.8.0/src-separate/duk_util.h.

271#define DUK_BW_WRITE_RAW_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \
272 duk_uint8_t *duk__p; \
273 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 6); \
274 duk__p = (bw_ctx)->p; \
275 *duk__p++ = (duk_uint8_t) (val1); \
276 *duk__p++ = (duk_uint8_t) (val2); \
277 *duk__p++ = (duk_uint8_t) (val3); \
278 *duk__p++ = (duk_uint8_t) (val4); \
279 *duk__p++ = (duk_uint8_t) (val5); \
280 *duk__p++ = (duk_uint8_t) (val6); \
281 (bw_ctx)->p = duk__p; \
282 } while (0)

◆ DUK_BW_WRITE_RAW_XUTF8

#define DUK_BW_WRITE_RAW_XUTF8 ( thr,
bw_ctx,
cp )
Value:
do { \
duk_ucodepoint_t duk__cp; \
duk_small_int_t duk__enc_len; \
duk__cp = (cp); \
DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_xutf8_length(duk__cp)); \
duk__enc_len = duk_unicode_encode_xutf8(duk__cp, (bw_ctx)->p); \
(bw_ctx)->p += duk__enc_len; \
} while (0)
duk_unicode_encode_xutf8
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_xutf8(duk_ucodepoint_t cp, duk_uint8_t *out)
Definition duktape-1.5.2/src-noline/duktape.c:9975
duk_unicode_get_xutf8_length
DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_xutf8_length(duk_ucodepoint_t cp)
Definition duktape-1.5.2/src-noline/duktape.c:9919

Definition at line 283 of file duktape-1.8.0/src-separate/duk_util.h.

283#define DUK_BW_WRITE_RAW_XUTF8(thr,bw_ctx,cp) do { \
284 duk_ucodepoint_t duk__cp; \
285 duk_small_int_t duk__enc_len; \
286 duk__cp = (cp); \
287 DUK_BW_ASSERT_SPACE((thr), (bw_ctx), duk_unicode_get_xutf8_length(duk__cp)); \
288 duk__enc_len = duk_unicode_encode_xutf8(duk__cp, (bw_ctx)->p); \
289 (bw_ctx)->p += duk__enc_len; \
290 } while (0)

◆ DUK_RAW_READ_DOUBLE_BE

#define DUK_RAW_READ_DOUBLE_BE ( ptr)    duk_raw_read_double_be(&(ptr));

Definition at line 90 of file duktape-1.8.0/src-separate/duk_util.h.

◆ DUK_RAW_READ_U16_BE

#define DUK_RAW_READ_U16_BE ( ptr)    duk_raw_read_u16_be(&(ptr));

Definition at line 88 of file duktape-1.8.0/src-separate/duk_util.h.

◆ DUK_RAW_READ_U32_BE

#define DUK_RAW_READ_U32_BE ( ptr)    duk_raw_read_u32_be(&(ptr));

Definition at line 89 of file duktape-1.8.0/src-separate/duk_util.h.

◆ DUK_RAW_READ_U8

#define DUK_RAW_READ_U8 ( ptr)    ((duk_uint8_t) (*(ptr)++))

Definition at line 87 of file duktape-1.8.0/src-separate/duk_util.h.

◆ DUK_RAW_WRITE_CESU8

#define DUK_RAW_WRITE_CESU8 ( ptr,
val )
Value:
do { \
/* 'ptr' is evaluated both as LHS and RHS. */ \
duk_uint8_t *duk__ptr; \
duk_small_int_t duk__len; \
duk__ptr = (duk_uint8_t *) (ptr); \
duk__len = duk_unicode_encode_cesu8((duk_ucodepoint_t) (val), duk__ptr); \
duk__ptr += duk__len; \
(ptr) = duk__ptr; \
} while (0)

Definition at line 77 of file duktape-1.8.0/src-separate/duk_util.h.

77#define DUK_RAW_WRITE_CESU8(ptr,val) do { \
78 /* 'ptr' is evaluated both as LHS and RHS. */ \
79 duk_uint8_t *duk__ptr; \
80 duk_small_int_t duk__len; \
81 duk__ptr = (duk_uint8_t *) (ptr); \
82 duk__len = duk_unicode_encode_cesu8((duk_ucodepoint_t) (val), duk__ptr); \
83 duk__ptr += duk__len; \
84 (ptr) = duk__ptr; \
85 } while (0)

◆ DUK_RAW_WRITE_DOUBLE_BE

#define DUK_RAW_WRITE_DOUBLE_BE ( ptr,
val )   duk_raw_write_double_be(&(ptr), (duk_double_t) (val))

Definition at line 67 of file duktape-1.8.0/src-separate/duk_util.h.

◆ DUK_RAW_WRITE_U16_BE

#define DUK_RAW_WRITE_U16_BE ( ptr,
val )   duk_raw_write_u16_be(&(ptr), (duk_uint16_t) (val))

Definition at line 65 of file duktape-1.8.0/src-separate/duk_util.h.

◆ DUK_RAW_WRITE_U32_BE

#define DUK_RAW_WRITE_U32_BE ( ptr,
val )   duk_raw_write_u32_be(&(ptr), (duk_uint32_t) (val))

Definition at line 66 of file duktape-1.8.0/src-separate/duk_util.h.

◆ DUK_RAW_WRITE_U8

#define DUK_RAW_WRITE_U8 ( ptr,
val )
Value:
do { \
*(ptr)++ = (duk_uint8_t) (val); \
} while (0)

Definition at line 62 of file duktape-1.8.0/src-separate/duk_util.h.

62#define DUK_RAW_WRITE_U8(ptr,val) do { \
63 *(ptr)++ = (duk_uint8_t) (val); \
64 } while (0)

◆ DUK_RAW_WRITE_XUTF8

#define DUK_RAW_WRITE_XUTF8 ( ptr,
val )
Value:
do { \
/* 'ptr' is evaluated both as LHS and RHS. */ \
duk_uint8_t *duk__ptr; \
duk_small_int_t duk__len; \
duk__ptr = (duk_uint8_t *) (ptr); \
duk__len = duk_unicode_encode_xutf8((duk_ucodepoint_t) (val), duk__ptr); \
duk__ptr += duk__len; \
(ptr) = duk__ptr; \
} while (0)

Definition at line 68 of file duktape-1.8.0/src-separate/duk_util.h.

68#define DUK_RAW_WRITE_XUTF8(ptr,val) do { \
69 /* 'ptr' is evaluated both as LHS and RHS. */ \
70 duk_uint8_t *duk__ptr; \
71 duk_small_int_t duk__len; \
72 duk__ptr = (duk_uint8_t *) (ptr); \
73 duk__len = duk_unicode_encode_xutf8((duk_ucodepoint_t) (val), duk__ptr); \
74 duk__ptr += duk__len; \
75 (ptr) = duk__ptr; \
76 } while (0)

◆ DUK_UTIL_GET_HASH_PROBE_STEP

#define DUK_UTIL_GET_HASH_PROBE_STEP ( hash)    (duk_util_probe_steps[(hash) & 0x1f])

Definition at line 10 of file duktape-1.8.0/src-separate/duk_util.h.

◆ DUK_UTIL_MIN_HASH_PRIME

#define DUK_UTIL_MIN_HASH_PRIME   17 /* must match genhashsizes.py */

Definition at line 8 of file duktape-1.8.0/src-separate/duk_util.h.

Function Documentation

◆ duk_bd_decode()

DUK_INTERNAL_DECL duk_int32_t duk_bd_decode ( duk_bitdecoder_ctx * ctx,
duk_small_int_t bits )

Definition at line 85971 of file duktape-1.5.2/src-noline/duktape.c.

85988 {
85989 duk_small_int_t shift;
85990 duk_uint32_t mask;
85991 duk_uint32_t tmp;
85992
85993 /* Note: cannot read more than 24 bits without possibly shifting top bits out.
85994 * Fixable, but adds complexity.
85995 */
85996 DUK_ASSERT(bits >= 1 && bits <= 24);
85997
85998 while (ctx->currbits < bits) {
85999#if 0
86000 DUK_DDD(DUK_DDDPRINT("decode_bits: shift more data (bits=%ld, currbits=%ld)",
86001 (long) bits, (long) ctx->currbits));
86002#endif
86003 ctx->currval <<= 8;
86004 if (ctx->offset < ctx->length) {
86005 /* If ctx->offset >= ctx->length, we "shift zeroes in"
86006 * instead of croaking.
86007 */
86008 ctx->currval |= ctx->data[ctx->offset++];
86009 }
86010 ctx->currbits += 8;
86011 }
86012#if 0
86013 DUK_DDD(DUK_DDDPRINT("decode_bits: bits=%ld, currbits=%ld, currval=0x%08lx",
86014 (long) bits, (long) ctx->currbits, (unsigned long) ctx->currval));
mask
#define mask(n)
Definition lua-5.2.4/src/lbitlib.c:29
duk_bitdecoder_ctx::length
duk_size_t length
Definition duktape-1.5.2/src-noline/duktape.c:1760
duk_bitdecoder_ctx::offset
duk_size_t offset
Definition duktape-1.5.2/src-noline/duktape.c:1759
duk_bitdecoder_ctx::data
const duk_uint8_t * data
Definition duktape-1.5.2/src-noline/duktape.c:1758
duk_bitdecoder_ctx::currbits
duk_small_int_t currbits
Definition duktape-1.5.2/src-noline/duktape.c:1762
duk_bitdecoder_ctx::currval
duk_uint32_t currval
Definition duktape-1.5.2/src-noline/duktape.c:1761

References duk_bitdecoder_ctx::currbits, duk_bitdecoder_ctx::currval, duk_bitdecoder_ctx::data, DUK_ASSERT, DUK_DDD, DUK_DDDPRINT, duk_bitdecoder_ctx::length, mask, and duk_bitdecoder_ctx::offset.

Referenced by duk__hobject_pc2line_query_raw(), duk__init_heap_strings(), duk__push_double(), duk__push_stridx(), duk__push_string(), duk__slow_case_conversion(), duk__uni_decode_value(), duk_bd_decode_flag(), duk_bd_decode_flagged(), duk_be_encode(), and duk_hthread_create_builtin_objects().

◆ duk_bd_decode_flag()

DUK_INTERNAL_DECL duk_small_int_t duk_bd_decode_flag ( duk_bitdecoder_ctx * ctx)

Definition at line 86016 of file duktape-1.5.2/src-noline/duktape.c.

References duk_bd_decode().

Referenced by duk__hobject_pc2line_query_raw(), duk__push_stridx_or_string(), duk_bd_decode_flagged(), duk_be_encode(), and duk_hthread_create_builtin_objects().

◆ duk_bd_decode_flagged()

DUK_INTERNAL_DECL duk_int32_t duk_bd_decode_flagged ( duk_bitdecoder_ctx * ctx,
duk_small_int_t bits,
duk_int32_t def_value )

Definition at line 86024 of file duktape-1.5.2/src-noline/duktape.c.

86026 : %ld bits -> 0x%08lx (%ld), currbits=%ld, currval=0x%08lx",
86027 (long) bits, (unsigned long) tmp, (long) tmp, (long) ctx->currbits, (unsigned long) ctx->currval));
86028#endif
86029
86030 return tmp;

References duk_bd_decode(), and duk_bd_decode_flag().

Referenced by duk_hthread_create_builtin_objects().

◆ duk_be_encode()

DUK_INTERNAL_DECL void duk_be_encode ( duk_bitencoder_ctx * ctx,
duk_uint32_t data,
duk_small_int_t bits )

Definition at line 86037 of file duktape-1.5.2/src-noline/duktape.c.

86041 {
86042 if (duk_bd_decode_flag(ctx)) {
86043 return (duk_int32_t) duk_bd_decode(ctx, bits);
86044 } else {
86045 return def_value;
86046 }
86047}
86048/*
86049 * Bitstream encoder.
86050 */
86051
86052/* include removed: duk_internal.h */
86053
86054DUK_INTERNAL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits) {
86055 duk_uint8_t tmp;
86056
86057 DUK_ASSERT(ctx != NULL);
86058 DUK_ASSERT(ctx->currbits < 8);
86059
86060 /* This limitation would be fixable but adds unnecessary complexity. */
DUK_INTERNAL
#define DUK_INTERNAL
Definition duktape-1.5.2/src-noline/duk_config.h:2548
duk_bd_decode_flag
DUK_INTERNAL_DECL duk_small_int_t duk_bd_decode_flag(duk_bitdecoder_ctx *ctx)
Definition duktape-1.5.2/src-noline/duktape.c:86016
duk_be_encode
DUK_INTERNAL_DECL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits)
Definition duktape-1.5.2/src-noline/duktape.c:86037
duk_bd_decode
DUK_INTERNAL_DECL duk_int32_t duk_bd_decode(duk_bitdecoder_ctx *ctx, duk_small_int_t bits)
Definition duktape-1.5.2/src-noline/duktape.c:85971
duk_bitencoder_ctx
Definition duktape-1.5.2/src-noline/duktape.c:1769
duk_bitencoder_ctx::currbits
duk_small_int_t currbits
Definition duktape-1.5.2/src-noline/duktape.c:1774

References duk_bitencoder_ctx::currbits, duk_bitencoder_ctx::currval, duk_bitencoder_ctx::data, DUK_ASSERT, duk_bd_decode(), duk_bd_decode_flag(), duk_bitencoder_ctx::length, NULL, duk_bitencoder_ctx::offset, and duk_bitencoder_ctx::truncated.

Referenced by duk__bw_update_ptrs(), duk_be_finish(), and duk_hobject_pc2line_pack().

◆ duk_be_finish()

DUK_INTERNAL_DECL void duk_be_finish ( duk_bitencoder_ctx * ctx)

Definition at line 86062 of file duktape-1.5.2/src-noline/duktape.c.

86066 {
86067 if (ctx->offset < ctx->length) {
86068 tmp = (duk_uint8_t) ((ctx->currval >> (ctx->currbits - 8)) & 0xff);
86069 ctx->data[ctx->offset++] = tmp;
86070 } else {
86071 /* If buffer has been exhausted, truncate bitstream */
86072 ctx->truncated = 1;
86073 }
duk_bitencoder_ctx::currval
duk_uint32_t currval
Definition duktape-1.5.2/src-noline/duktape.c:1773
duk_bitencoder_ctx::truncated
duk_small_int_t truncated
Definition duktape-1.5.2/src-noline/duktape.c:1775
duk_bitencoder_ctx::length
duk_size_t length
Definition duktape-1.5.2/src-noline/duktape.c:1772
duk_bitencoder_ctx::data
duk_uint8_t * data
Definition duktape-1.5.2/src-noline/duktape.c:1770
duk_bitencoder_ctx::offset
duk_size_t offset
Definition duktape-1.5.2/src-noline/duktape.c:1771

References duk_bitencoder_ctx::currbits, duk_bitencoder_ctx::currval, duk_bitencoder_ctx::data, DUK_ASSERT, duk_be_encode(), duk_bitencoder_ctx::length, NULL, duk_bitencoder_ctx::offset, and duk_bitencoder_ctx::truncated.

Referenced by duk_hobject_pc2line_pack().

◆ duk_bw_compact()

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

Definition at line 86162 of file duktape-1.5.2/src-noline/duktape.c.

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_DECL void duk_bw_init ( duk_hthread * thr,
duk_bufwriter_ctx * bw_ctx,
duk_hbuffer_dynamic * h_buf )

Definition at line 86098 of file duktape-1.5.2/src-noline/duktape.c.

86101 {
86102 duk_uint8_t *p;
86103
86104 DUK_ASSERT(thr != NULL);
86105 DUK_ASSERT(bw_ctx != NULL);
86106 DUK_UNREF(thr);
86107
DUK_UNREF
#define DUK_UNREF(x)
Definition duktape-1.5.2/src-noline/duk_config.h:2494

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

◆ duk_bw_init_pushbuf()

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

Definition at line 86109 of file duktape-1.5.2/src-noline/duktape.c.

86115 {
86116
86117 DUK_ASSERT(thr != NULL);
86118 DUK_ASSERT(bw_ctx != NULL);
86119 DUK_ASSERT(h_buf != NULL);

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_DECL 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 86309 of file duktape-1.5.2/src-noline/duktape.c.

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_DECL 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 86227 of file duktape-1.5.2/src-noline/duktape.c.

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_DECL 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 86275 of file duktape-1.5.2/src-noline/duktape.c.

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_DECL 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 86291 of file duktape-1.5.2/src-noline/duktape.c.

86292 {
86293 DUK_ASSERT(thr != NULL);
86294 DUK_ASSERT(bw != NULL);
86295 DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
86296 DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
86297 DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
86298 DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
86299 DUK_UNREF(thr);
86300
86301 /* Don't support "straddled" source now. */
86302 DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len);
86303
86304 DUK_BW_ENSURE(thr, bw, len);
86305 duk_bw_insert_raw_slice(thr, bw, dst_off, src_off, len);
86306}
86307
DUK_BW_ENSURE
#define DUK_BW_ENSURE(thr, bw_ctx, sz)
Definition duktape-1.5.2/src-noline/duktape.c:1915
DUK_BW_GET_SIZE
#define DUK_BW_GET_SIZE(thr, bw_ctx)
Definition duktape-1.5.2/src-noline/duktape.c:1900
duk_bw_insert_raw_slice
DUK_INTERNAL_DECL 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 duktape-1.5.2/src-noline/duktape.c:86238

References DUK_ASSERT, DUK_BW_ENSURE, DUK_BW_GET_SIZE, duk_bw_insert_raw_slice(), 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_DECL 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 86203 of file duktape-1.5.2/src-noline/duktape.c.

86208 {
86209 DUK_ASSERT(thr != NULL);
86210 DUK_ASSERT(bw != NULL);
86211 DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
86212 DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
86213 DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
86214 DUK_UNREF(thr);
86215
86216 DUK_BW_ENSURE(thr, bw, len);
86217 duk_bw_write_raw_slice(thr, bw, src_off, len);
86218}
86219
86220DUK_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) {
86221 duk_uint8_t *p_base;
86222 duk_size_t buf_sz, move_sz;
86223
86224 DUK_ASSERT(thr != NULL);
86225 DUK_ASSERT(bw != NULL);
duk_bw_insert_raw_bytes
DUK_INTERNAL_DECL 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 duktape-1.5.2/src-noline/duktape.c:86203
duk_bw_write_raw_slice
DUK_INTERNAL_DECL void duk_bw_write_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len)
Definition duktape-1.5.2/src-noline/duktape.c:86174
duk_bufwriter_ctx
Definition duktape-1.5.2/src-noline/duktape.c:1840

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_DECL 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 86238 of file duktape-1.5.2/src-noline/duktape.c.

86244 {
86245 DUK_ASSERT(thr != NULL);
86246 DUK_ASSERT(bw != NULL);
86247 DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
86248 DUK_ASSERT(buf != NULL);
86249 DUK_UNREF(thr);
86250
86251 DUK_BW_ENSURE(thr, bw, len);
86252 duk_bw_insert_raw_bytes(thr, bw, dst_off, buf, len);
86253}
86254
86255DUK_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) {
86256 duk_uint8_t *p_base;
86257 duk_size_t buf_sz, move_sz;
86258
86259 DUK_ASSERT(thr != NULL);
86260 DUK_ASSERT(bw != NULL);
86261 DUK_ASSERT(dst_off <= DUK_BW_GET_SIZE(thr, bw));
86262 DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
86263 DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
86264 DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
86265 DUK_UNREF(thr);
86266
86267 p_base = bw->p_base;
86268
86269 /* Don't support "straddled" source now. */
86270 DUK_ASSERT(dst_off <= src_off || dst_off >= src_off + len);
86271
86272 if (dst_off <= src_off) {
86273 /* Target is before source. Source offset is expressed as
duk_bufwriter_ctx::p_base
duk_uint8_t * p_base
Definition duktape-1.5.2/src-noline/duktape.c:1842

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(), and duk_bw_insert_raw_area().

◆ duk_bw_remove_raw_slice()

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

Definition at line 86319 of file duktape-1.5.2/src-noline/duktape.c.

86326 {
86327 DUK_ASSERT(thr != NULL);
86328 DUK_ASSERT(bw != NULL);
86329 DUK_ASSERT(off <= DUK_BW_GET_SIZE(thr, bw));
86330 DUK_UNREF(thr);
86331
86332 DUK_BW_ENSURE(thr, bw, len);
86333 return duk_bw_insert_raw_area(thr, bw, off, len);
86334}
86335
86336DUK_INTERNAL void duk_bw_remove_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len) {
86337 duk_size_t move_sz;
86338
86339 duk_uint8_t *p_base;
86340 duk_uint8_t *p_src;
86341 duk_uint8_t *p_dst;
duk_bw_remove_raw_slice
DUK_INTERNAL_DECL void duk_bw_remove_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len)
Definition duktape-1.5.2/src-noline/duktape.c:86319
duk_bw_insert_raw_area
DUK_INTERNAL_DECL duk_uint8_t * duk_bw_insert_raw_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len)
Definition duktape-1.5.2/src-noline/duktape.c:86291

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_DECL duk_uint8_t * duk_bw_resize ( duk_hthread * thr,
duk_bufwriter_ctx * bw_ctx,
duk_size_t sz )

Definition at line 86124 of file duktape-1.5.2/src-noline/duktape.c.

86126 {
86127 duk_context *ctx;
86128
86129 DUK_ASSERT(thr != NULL);
86130 DUK_ASSERT(bw_ctx != NULL);
86131 ctx = (duk_context *) thr;
86132
86133 (void) duk_push_dynamic_buffer(ctx, buf_size);
86134 bw_ctx->buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
86135 duk__bw_update_ptrs(thr, bw_ctx, 0, buf_size);
86136}
86137
86138/* Resize target buffer for requested size. Called by the macro only when the
86139 * fast path test (= there is space) fails.
86140 */
86141DUK_INTERNAL duk_uint8_t *duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz) {
86142 duk_size_t curr_off;
86143 duk_size_t add_sz;
86144 duk_size_t new_sz;
86145
86146 DUK_ASSERT(thr != NULL);
86147 DUK_ASSERT(bw_ctx != NULL);
86148
86149 /* We could do this operation without caller updating bw_ctx->ptr,
86150 * but by writing it back here we can share code better.
86151 */
86152
86153 curr_off = (duk_size_t) (bw_ctx->p - bw_ctx->p_base);
86154 add_sz = (curr_off >> DUK_BW_SPARE_SHIFT) + DUK_BW_SPARE_ADD;
86155 new_sz = curr_off + sz + add_sz;
86156 if (new_sz < curr_off) {
86157 /* overflow */
86158 DUK_ERROR_RANGE(thr, DUK_STR_BUFFER_TOO_LONG);
86159 return NULL; /* not reachable */
DUK_ERROR_RANGE
#define DUK_ERROR_RANGE(thr, msg)
Definition duktape-1.5.2/src-noline/duktape.c:7875
duk_bw_resize
DUK_INTERNAL_DECL duk_uint8_t * duk_bw_resize(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx, duk_size_t sz)
Definition duktape-1.5.2/src-noline/duktape.c:86124
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 duktape-1.5.2/src-noline/duktape.c:86084
DUK_STR_BUFFER_TOO_LONG
#define DUK_STR_BUFFER_TOO_LONG
Definition duktape-1.5.2/src-noline/duktape.c:2319
duk_get_hbuffer
DUK_INTERNAL_DECL duk_hbuffer * duk_get_hbuffer(duk_context *ctx, duk_idx_t index)
Definition duktape-1.5.2/src-noline/duktape.c:16314
duk_push_dynamic_buffer
#define duk_push_dynamic_buffer(ctx, size)
Definition duktape-1.5.2/src-noline/duktape.h:572
duk_bufwriter_ctx::buf
duk_hbuffer_dynamic * buf
Definition duktape-1.5.2/src-noline/duktape.c:1844
duk_bufwriter_ctx::p
duk_uint8_t * p
Definition duktape-1.5.2/src-noline/duktape.c:1841
duk_hbuffer_dynamic
Definition duktape-1.5.2/src-noline/duktape.c:6589

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_DECL 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 86191 of file duktape-1.5.2/src-noline/duktape.c.

86191 {
86192 duk_uint8_t *p_base;
86193
86194 DUK_ASSERT(thr != NULL);
86195 DUK_ASSERT(bw != NULL);
86196 DUK_ASSERT(src_off <= DUK_BW_GET_SIZE(thr, bw));
86197 DUK_ASSERT(len <= DUK_BW_GET_SIZE(thr, bw));
86198 DUK_ASSERT(src_off + len <= DUK_BW_GET_SIZE(thr, bw));
86199 DUK_UNREF(thr);
86200
86201 p_base = bw->p_base;

References DUK_ASSERT, DUK_BW_ENSURE, DUK_BW_GET_SIZE, duk_bw_write_raw_slice(), DUK_MEMCPY, DUK_UNREF, NULL, duk_bufwriter_ctx::p, and duk_bufwriter_ctx::p_base.

◆ duk_bw_write_raw_slice()

DUK_INTERNAL_DECL 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 86174 of file duktape-1.5.2/src-noline/duktape.c.

86179 {
86180 duk_size_t len;
86181
86182 DUK_ASSERT(thr != NULL);
86183 DUK_ASSERT(bw_ctx != NULL);
86184 DUK_UNREF(thr);
86185
86186 len = (duk_size_t) (bw_ctx->p - bw_ctx->p_base);
86187 duk_hbuffer_resize(thr, bw_ctx->buf, len);
86188 duk__bw_update_ptrs(thr, bw_ctx, len, len);
86189}
duk_hbuffer_resize
DUK_INTERNAL_DECL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size)
Definition duktape-1.5.2/src-noline/duktape.c:40615

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_DECL duk_double_t duk_raw_read_double_be ( duk_uint8_t ** p)

Definition at line 86378 of file duktape-1.5.2/src-noline/duktape.c.

86383 {
86384 union {
86385 duk_uint8_t b[4];
86386 duk_uint32_t x;
86387 } u;
86388
86389 DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 4);
86390 u.x = DUK_NTOH32(u.x);
86391 *p += 4;
86392 return u.x;
86393}
86394
DUK_MEMCPY
#define DUK_MEMCPY
Definition duktape-1.5.2/src-noline/duk_config.h:1984

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

◆ duk_raw_read_u16_be()

DUK_INTERNAL_DECL duk_uint16_t duk_raw_read_u16_be ( duk_uint8_t ** p)

Definition at line 86354 of file duktape-1.5.2/src-noline/duktape.c.

References DUK_MEMCPY.

◆ duk_raw_read_u32_be()

DUK_INTERNAL_DECL duk_uint32_t duk_raw_read_u32_be ( duk_uint8_t ** p)

Definition at line 86366 of file duktape-1.5.2/src-noline/duktape.c.

86371 {
86372 union {
86373 duk_uint8_t b[2];
86374 duk_uint16_t x;
86375 } u;
86376

References DUK_MEMCPY.

◆ duk_raw_write_double_be()

DUK_INTERNAL_DECL void duk_raw_write_double_be ( duk_uint8_t ** p,
duk_double_t val )

Definition at line 86418 of file duktape-1.5.2/src-noline/duktape.c.

86424 {
86425 union {
86426 duk_uint8_t b[4];
86427 duk_uint32_t x;
86428 } u;
86429
86430 u.x = DUK_HTON32(val);
86431 DUK_MEMCPY((void *) (*p), (const void *) u.b, (size_t) 4);
86432 *p += 4;
86433}

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

◆ duk_raw_write_u16_be()

DUK_INTERNAL_DECL void duk_raw_write_u16_be ( duk_uint8_t ** p,
duk_uint16_t val )

Definition at line 86396 of file duktape-1.5.2/src-noline/duktape.c.

86397 {
86398 duk_uint8_t b[4];
86399 duk_uint32_t x;
86400 } u;
86401
86402 DUK_MEMCPY((void *) u.b, (const void *) (*p), (size_t) 4);
86403 u.x = DUK_NTOH32(u.x);
86404 du.ui[DUK_DBL_IDX_UI0] = u.x;
86405 DUK_MEMCPY((void *) u.b, (const void *) (*p + 4), (size_t) 4);

References DUK_MEMCPY.

◆ duk_raw_write_u32_be()

DUK_INTERNAL_DECL void duk_raw_write_u32_be ( duk_uint8_t ** p,
duk_uint32_t val )

Definition at line 86407 of file duktape-1.5.2/src-noline/duktape.c.

86413 {
86414 union {
86415 duk_uint8_t b[2];
86416 duk_uint16_t x;

References DUK_MEMCPY.

◆ duk_util_tinyrandom_get_bits()

DUK_INTERNAL_DECL duk_uint32_t duk_util_tinyrandom_get_bits ( duk_hthread * thr,
duk_small_int_t n )

Definition at line 86508 of file duktape-1.5.2/src-noline/duktape.c.

86518 { \
86519 (rnd) += ((rnd) * (rnd)) | 0x05; \
86520 (rnd) = ((rnd) & 0xffffffffU); /* if duk_uint32_t is exactly 32 bits, this is a NOP */ \
86521 } while (0)
86522
86523#define DUK__RND_BIT(rnd) ((rnd) >> 31) /* only use the highest bit */
86524

References DUK__RND_BIT, DUK__UPDATE_RND, duk_hthread::heap, and duk_heap::rnd_state.

Referenced by duk__array_qsort().

◆ duk_util_tinyrandom_get_double()

DUK_INTERNAL_DECL duk_double_t duk_util_tinyrandom_get_double ( duk_hthread * thr)

Definition at line 86526 of file duktape-1.5.2/src-noline/duktape.c.

86532 {
86533 DUK__UPDATE_RND(rnd);
86534 res <<= 1;
86535 res += DUK__RND_BIT(rnd);
86536 }
86537
86538 thr->heap->rnd_state = rnd;
86539
86540 return res;
86541}
86542
86543DUK_INTERNAL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr) {
86544 duk_double_t t;
86545 duk_small_int_t n;
86546 duk_uint32_t rnd;
86547
86548 /*
86549 * XXX: could make this a lot faster if we create the double memory
86550 * representation directly. Feasible easily (must be uniform random).
86551 */
86552
86553 rnd = thr->heap->rnd_state;
duk_double_t
double duk_double_t
Definition duktape-1.5.2/src-noline/duk_config.h:1877
duk_util_tinyrandom_get_double
DUK_INTERNAL_DECL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr)
Definition duktape-1.5.2/src-noline/duktape.c:86526
DUK__UPDATE_RND
#define DUK__UPDATE_RND(rnd)
Definition duktape-1.5.2/src-noline/duktape.c:86501
DUK__RND_BIT
#define DUK__RND_BIT(rnd)
Definition duktape-1.5.2/src-noline/duktape.c:86506
duk_heap::rnd_state
duk_uint32_t rnd_state
Definition duktape-1.5.2/src-noline/duktape.c:7057
duk_hthread::heap
duk_heap * heap
Definition duktape-1.5.2/src-noline/duktape.c:6202

References DUK__RND_BIT, DUK__UPDATE_RND, DUK_ASSERT, duk_hthread::heap, and duk_heap::rnd_state.

Referenced by duk_bi_math_object_random().

Variable Documentation

◆ duk_hex_dectab

DUK_INTERNAL_DECL const duk_int8_t duk_hex_dectab[256]

Definition at line 468 of file duktape-1.8.0/src-separate/duk_util.h.

◆ duk_lc_digits

DUK_INTERNAL_DECL const duk_uint8_t duk_lc_digits[36]

Definition at line 466 of file duktape-1.8.0/src-separate/duk_util.h.

◆ duk_uc_nybbles

DUK_INTERNAL_DECL const duk_uint8_t duk_uc_nybbles[16]

Definition at line 467 of file duktape-1.8.0/src-separate/duk_util.h.