http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/ede68a10/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_alloc.c ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_alloc.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_alloc.c deleted file mode 100644 index 425ad33..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_alloc.c +++ /dev/null @@ -1,132 +0,0 @@ -/* - * duk_hbuffer allocation and freeing. - */ - -#include "duk_internal.h" - -/* Allocate a new duk_hbuffer of a certain type and return a pointer to it - * (NULL on error). Write buffer data pointer to 'out_bufdata' (only if - * allocation successful). - */ -DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags, void **out_bufdata) { - duk_hbuffer *res = NULL; - duk_size_t header_size; - duk_size_t alloc_size; - - DUK_ASSERT(heap != NULL); - DUK_ASSERT(out_bufdata != NULL); - - DUK_DDD(DUK_DDDPRINT("allocate hbuffer")); - - /* Size sanity check. Should not be necessary because caller is - * required to check this, but we don't want to cause a segfault - * if the size wraps either in duk_size_t computation or when - * storing the size in a 16-bit field. - */ - if (size > DUK_HBUFFER_MAX_BYTELEN) { - DUK_D(DUK_DPRINT("hbuffer alloc failed: size too large: %ld", (long) size)); - return NULL; /* no need to write 'out_bufdata' */ - } - - if (flags & DUK_BUF_FLAG_EXTERNAL) { - header_size = sizeof(duk_hbuffer_external); - alloc_size = sizeof(duk_hbuffer_external); - } else if (flags & DUK_BUF_FLAG_DYNAMIC) { - header_size = sizeof(duk_hbuffer_dynamic); - alloc_size = sizeof(duk_hbuffer_dynamic); - } else { - header_size = sizeof(duk_hbuffer_fixed); - alloc_size = sizeof(duk_hbuffer_fixed) + size; - DUK_ASSERT(alloc_size >= sizeof(duk_hbuffer_fixed)); /* no wrapping */ - } - - res = (duk_hbuffer *) DUK_ALLOC(heap, alloc_size); - if (!res) { - goto error; - } - - /* zero everything unless requested not to do so */ -#if defined(DUK_USE_ZERO_BUFFER_DATA) - DUK_MEMZERO((void *) res, - (flags & DUK_BUF_FLAG_NOZERO) ? header_size : alloc_size); -#else - DUK_MEMZERO((void *) res, header_size); -#endif - - if (flags & DUK_BUF_FLAG_EXTERNAL) { - duk_hbuffer_external *h; - h = (duk_hbuffer_external *) res; - DUK_UNREF(h); - *out_bufdata = NULL; -#if defined(DUK_USE_EXPLICIT_NULL_INIT) -#if defined(DUK_USE_HEAPPTR16) -/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */ -#else - DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap, h, NULL); -#endif -#endif - DUK_ASSERT(DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap, h) == NULL); - } else if (flags & DUK_BUF_FLAG_DYNAMIC) { - duk_hbuffer_dynamic *h = (duk_hbuffer_dynamic *) res; - void *ptr; - - if (size > 0) { - DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL)); /* alloc external with size zero */ - DUK_DDD(DUK_DDDPRINT("dynamic buffer with nonzero size, alloc actual buffer")); -#ifdef DUK_USE_ZERO_BUFFER_DATA - ptr = DUK_ALLOC_ZEROED(heap, size); -#else - ptr = DUK_ALLOC(heap, size); -#endif - if (!ptr) { - /* Because size > 0, NULL check is correct */ - goto error; - } - *out_bufdata = ptr; - - DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, ptr); - } else { - *out_bufdata = NULL; -#if defined(DUK_USE_EXPLICIT_NULL_INIT) -#if defined(DUK_USE_HEAPPTR16) -/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */ -#else - DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, NULL); -#endif -#endif - DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, h) == NULL); - } - } else { - *out_bufdata = (void *) ((duk_hbuffer_fixed *) res + 1); - } - - DUK_HBUFFER_SET_SIZE(res, size); - - DUK_HEAPHDR_SET_TYPE(&res->hdr, DUK_HTYPE_BUFFER); - if (flags & DUK_BUF_FLAG_DYNAMIC) { - DUK_HBUFFER_SET_DYNAMIC(res); - if (flags & DUK_BUF_FLAG_EXTERNAL) { - DUK_HBUFFER_SET_EXTERNAL(res); - } - } else { - DUK_ASSERT(!(flags & DUK_BUF_FLAG_EXTERNAL)); - } - DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, &res->hdr); - - DUK_DDD(DUK_DDDPRINT("allocated hbuffer: %p", (void *) res)); - return res; - - error: - DUK_DD(DUK_DDPRINT("hbuffer allocation failed")); - - DUK_FREE(heap, res); - return NULL; /* no need to write 'out_bufdata' */ -} - -/* For indirect allocs. */ - -DUK_INTERNAL void *duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud) { - duk_hbuffer_dynamic *buf = (duk_hbuffer_dynamic *) ud; - DUK_UNREF(heap); - return (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, buf); -}
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/ede68a10/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_ops.c ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_ops.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_ops.c deleted file mode 100644 index 4cdf598..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_ops.c +++ /dev/null @@ -1,82 +0,0 @@ -/* - * duk_hbuffer operations such as resizing and inserting/appending data to - * a dynamic buffer. - * - * Append operations append to the end of the buffer and they are relatively - * efficient: the buffer is grown with a "spare" part relative to the buffer - * size to minimize reallocations. Insert operations need to move existing - * data forward in the buffer with memmove() and are not very efficient. - * They are used e.g. by the regexp compiler to "backpatch" regexp bytecode. - */ - -#include "duk_internal.h" - -/* - * Resizing - */ - -DUK_INTERNAL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size) { - void *res; - duk_size_t prev_size; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - DUK_ASSERT(!DUK_HBUFFER_HAS_EXTERNAL(buf)); - - /* - * Maximum size check - */ - - if (new_size > DUK_HBUFFER_MAX_BYTELEN) { - DUK_ERROR_RANGE(thr, "buffer too long"); - } - - /* - * Note: use indirect realloc variant just in case mark-and-sweep - * (finalizers) might resize this same buffer during garbage - * collection. - */ - - res = DUK_REALLOC_INDIRECT(thr->heap, duk_hbuffer_get_dynalloc_ptr, (void *) buf, new_size); - if (res != NULL || new_size == 0) { - /* 'res' may be NULL if new allocation size is 0. */ - - DUK_DDD(DUK_DDDPRINT("resized dynamic buffer %p:%ld -> %p:%ld", - (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf), - (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(buf), - (void *) res, - (long) new_size)); - - /* - * The entire allocated buffer area, regardless of actual used - * size, is kept zeroed in resizes for simplicity. If the buffer - * is grown, zero the new part. - */ - - prev_size = DUK_HBUFFER_DYNAMIC_GET_SIZE(buf); - if (new_size > prev_size) { - DUK_ASSERT(new_size - prev_size > 0); -#ifdef DUK_USE_ZERO_BUFFER_DATA - DUK_MEMZERO((void *) ((char *) res + prev_size), - (duk_size_t) (new_size - prev_size)); -#endif - } - - DUK_HBUFFER_DYNAMIC_SET_SIZE(buf, new_size); - DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(thr->heap, buf, res); - } else { - DUK_ERROR_ALLOC_DEFMSG(thr); - } - - DUK_ASSERT(res != NULL || new_size == 0); -} - -DUK_INTERNAL void duk_hbuffer_reset(duk_hthread *thr, duk_hbuffer_dynamic *buf) { - DUK_ASSERT(thr != NULL); - DUK_ASSERT(buf != NULL); - DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf)); - DUK_ASSERT(!DUK_HBUFFER_HAS_EXTERNAL(buf)); - - duk_hbuffer_resize(thr, buf, 0); -} http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/ede68a10/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject.h ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject.h b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject.h deleted file mode 100644 index dd93902..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject.h +++ /dev/null @@ -1,133 +0,0 @@ -/* - * Heap Buffer object representation. Used for all Buffer variants. - */ - -#ifndef DUK_HBUFFEROBJECT_H_INCLUDED -#define DUK_HBUFFEROBJECT_H_INCLUDED - -/* All element accessors are host endian now (driven by TypedArray spec). */ -#define DUK_HBUFFEROBJECT_ELEM_UINT8 0 -#define DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED 1 -#define DUK_HBUFFEROBJECT_ELEM_INT8 2 -#define DUK_HBUFFEROBJECT_ELEM_UINT16 3 -#define DUK_HBUFFEROBJECT_ELEM_INT16 4 -#define DUK_HBUFFEROBJECT_ELEM_UINT32 5 -#define DUK_HBUFFEROBJECT_ELEM_INT32 6 -#define DUK_HBUFFEROBJECT_ELEM_FLOAT32 7 -#define DUK_HBUFFEROBJECT_ELEM_FLOAT64 8 -#define DUK_HBUFFEROBJECT_ELEM_MAX 8 - -#define DUK_ASSERT_HBUFFEROBJECT_VALID(h) do { \ - DUK_ASSERT((h) != NULL); \ - DUK_ASSERT((h)->shift <= 3); \ - DUK_ASSERT((h)->elem_type <= DUK_HBUFFEROBJECT_ELEM_MAX); \ - DUK_ASSERT(((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8) || \ - ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT8CLAMPED) || \ - ((h)->shift == 0 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT8) || \ - ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT16) || \ - ((h)->shift == 1 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT16) || \ - ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_UINT32) || \ - ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_INT32) || \ - ((h)->shift == 2 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT32) || \ - ((h)->shift == 3 && (h)->elem_type == DUK_HBUFFEROBJECT_ELEM_FLOAT64)); \ - DUK_ASSERT((h)->is_view == 0 || (h)->is_view == 1); \ - DUK_ASSERT(DUK_HOBJECT_IS_BUFFEROBJECT((duk_hobject *) (h))); \ - if ((h)->buf == NULL) { \ - DUK_ASSERT((h)->offset == 0); \ - DUK_ASSERT((h)->length == 0); \ - } else { \ - /* No assertions for offset or length; in particular, \ - * it's OK for length to be longer than underlying \ - * buffer. Just ensure they don't wrap when added. \ - */ \ - DUK_ASSERT((h)->offset + (h)->length >= (h)->offset); \ - } \ - } while (0) - -/* Get the current data pointer (caller must ensure buf != NULL) as a - * duk_uint8_t ptr. - */ -#define DUK_HBUFFEROBJECT_GET_SLICE_BASE(heap,h) \ - (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ - (((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR((heap), (h)->buf)) + (h)->offset)) - -/* True if slice is full, i.e. offset is zero and length covers the entire - * buffer. This status may change independently of the duk_hbufferobject if - * the underlying buffer is dynamic and changes without the hbufferobject - * being changed. - */ -#define DUK_HBUFFEROBJECT_FULL_SLICE(h) \ - (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ - ((h)->offset == 0 && (h)->length == DUK_HBUFFER_GET_SIZE((h)->buf))) - -/* Validate that the whole slice [0,length[ is contained in the underlying - * buffer. Caller must ensure 'buf' != NULL. - */ -#define DUK_HBUFFEROBJECT_VALID_SLICE(h) \ - (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ - ((h)->offset + (h)->length <= DUK_HBUFFER_GET_SIZE((h)->buf))) - -/* Validate byte read/write for virtual 'offset', i.e. check that the - * offset, taking into account h->offset, is within the underlying - * buffer size. This is a safety check which is needed to ensure - * that even a misconfigured duk_hbufferobject never causes memory - * unsafe behavior (e.g. if an underlying dynamic buffer changes - * after being setup). Caller must ensure 'buf' != NULL. - */ -#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_INCL(h,off) \ - (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ - ((h)->offset + (off) < DUK_HBUFFER_GET_SIZE((h)->buf))) - -#define DUK_HBUFFEROBJECT_VALID_BYTEOFFSET_EXCL(h,off) \ - (DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \ - ((h)->offset + (off) <= DUK_HBUFFER_GET_SIZE((h)->buf))) - -/* Clamp an input byte length (already assumed to be within the nominal - * duk_hbufferobject 'length') to the current dynamic buffer limits to - * yield a byte length limit that's safe for memory accesses. This value - * can be invalidated by any side effect because it may trigger a user - * callback that resizes the underlying buffer. - */ -#define DUK_HBUFFEROBJECT_CLAMP_BYTELENGTH(h,len) \ - (DUK_ASSERT_EXPR((h) != NULL), \ - duk_hbufferobject_clamp_bytelength((h), (len))) - -struct duk_hbufferobject { - /* Shared object part. */ - duk_hobject obj; - - /* Underlying buffer (refcounted), may be NULL. */ - duk_hbuffer *buf; - - /* Slice and accessor information. - * - * Because the underlying buffer may be dynamic, these may be - * invalidated by the buffer being modified so that both offset - * and length should be validated before every access. Behavior - * when the underlying buffer has changed doesn't need to be clean: - * virtual 'length' doesn't need to be affected, reads can return - * zero/NaN, and writes can be ignored. - * - * Note that a data pointer cannot be precomputed because 'buf' may - * be dynamic and its pointer unstable. - */ - - duk_uint_t offset; /* byte offset to buf */ - duk_uint_t length; /* byte index limit for element access, exclusive */ - duk_uint8_t shift; /* element size shift: - * 0 = u8/i8 - * 1 = u16/i16 - * 2 = u32/i32/float - * 3 = double - */ - duk_uint8_t elem_type; /* element type */ - duk_uint8_t is_view; -}; - -#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) -DUK_INTERNAL_DECL duk_uint_t duk_hbufferobject_clamp_bytelength(duk_hbufferobject *h_bufobj, duk_uint_t len); -#endif -DUK_INTERNAL_DECL void duk_hbufferobject_push_validated_read(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size); -DUK_INTERNAL_DECL void duk_hbufferobject_validated_write(duk_context *ctx, duk_hbufferobject *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size); - -#endif /* DUK_HBUFFEROBJECT_H_INCLUDED */ http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/ede68a10/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject_misc.c ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject_misc.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject_misc.c deleted file mode 100644 index f692918..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject_misc.c +++ /dev/null @@ -1,20 +0,0 @@ -#include "duk_internal.h" - -#if defined(DUK_USE_BUFFEROBJECT_SUPPORT) -DUK_INTERNAL duk_uint_t duk_hbufferobject_clamp_bytelength(duk_hbufferobject *h_bufobj, duk_uint_t len) { - duk_uint_t buf_size; - duk_uint_t buf_avail; - - DUK_ASSERT(h_bufobj != NULL); - DUK_ASSERT(h_bufobj->buf != NULL); - - buf_size = (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_bufobj->buf); - if (h_bufobj->offset > buf_size) { - /* Slice starting point is beyond current length. */ - return 0; - } - buf_avail = buf_size - h_bufobj->offset; - - return buf_avail >= len ? len : buf_avail; -} -#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */ http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/ede68a10/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hcompiledfunction.h ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hcompiledfunction.h b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hcompiledfunction.h deleted file mode 100644 index 04b9ea1..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hcompiledfunction.h +++ /dev/null @@ -1,239 +0,0 @@ -/* - * Heap compiled function (Ecmascript function) representation. - * - * There is a single data buffer containing the Ecmascript function's - * bytecode, constants, and inner functions. - */ - -#ifndef DUK_HCOMPILEDFUNCTION_H_INCLUDED -#define DUK_HCOMPILEDFUNCTION_H_INCLUDED - -/* - * Field accessor macros - */ - -/* XXX: casts could be improved, especially for GET/SET DATA */ - -#if defined(DUK_USE_HEAPPTR16) -#define DUK_HCOMPILEDFUNCTION_GET_DATA(heap,h) \ - ((duk_hbuffer_fixed *) (void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->data16)) -#define DUK_HCOMPILEDFUNCTION_SET_DATA(heap,h,v) do { \ - (h)->data16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ - } while (0) -#define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap,h) \ - ((duk_hobject **) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->funcs16))) -#define DUK_HCOMPILEDFUNCTION_SET_FUNCS(heap,h,v) do { \ - (h)->funcs16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ - } while (0) -#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap,h) \ - ((duk_instr_t *) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->bytecode16))) -#define DUK_HCOMPILEDFUNCTION_SET_BYTECODE(heap,h,v) do { \ - (h)->bytecode16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \ - } while (0) -#else -#define DUK_HCOMPILEDFUNCTION_GET_DATA(heap,h) \ - ((duk_hbuffer_fixed *) (void *) (h)->data) -#define DUK_HCOMPILEDFUNCTION_SET_DATA(heap,h,v) do { \ - (h)->data = (duk_hbuffer *) (v); \ - } while (0) -#define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap,h) \ - ((h)->funcs) -#define DUK_HCOMPILEDFUNCTION_SET_FUNCS(heap,h,v) do { \ - (h)->funcs = (v); \ - } while (0) -#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap,h) \ - ((h)->bytecode) -#define DUK_HCOMPILEDFUNCTION_SET_BYTECODE(heap,h,v) do { \ - (h)->bytecode = (v); \ - } while (0) -#endif - -/* - * Accessor macros for function specific data areas - */ - -/* Note: assumes 'data' is always a fixed buffer */ -#define DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE(heap,h) \ - DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h))) - -#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap,h) \ - ((duk_tval *) (void *) DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE((heap), (h))) - -#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap,h) \ - DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h)) - -#define DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(heap,h) \ - DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h)) - -#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap,h) \ - ((duk_tval *) (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h))) - -#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap,h) \ - ((duk_hobject **) (void *) DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h))) - -/* XXX: double evaluation of DUK_HCOMPILEDFUNCTION_GET_DATA() */ -#define DUK_HCOMPILEDFUNCTION_GET_CODE_END(heap,h) \ - ((duk_instr_t *) (void *) (DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h))) + \ - DUK_HBUFFER_GET_SIZE((duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA((heap), h)))) - -#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(heap,h) \ - ( \ - (duk_size_t) \ - ( \ - ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END((heap), (h))) - \ - ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE((heap), (h))) \ - ) \ - ) - -#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(heap,h) \ - ( \ - (duk_size_t) \ - ( \ - ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END((heap), (h))) - \ - ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE((heap), (h))) \ - ) \ - ) - -#define DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(heap,h) \ - ( \ - (duk_size_t) \ - ( \ - ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END((heap),(h))) - \ - ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE((heap),(h))) \ - ) \ - ) - -#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(heap,h) \ - ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval))) - -#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(heap,h) \ - ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE((heap), (h)) / sizeof(duk_hobject *))) - -#define DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(heap,h) \ - ((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE((heap), (h)) / sizeof(duk_instr_t))) - - -/* - * Main struct - */ - -struct duk_hcompiledfunction { - /* shared object part */ - duk_hobject obj; - - /* - * Pointers to function data area for faster access. Function - * data is a buffer shared between all closures of the same - * "template" function. The data buffer is always fixed (non- - * dynamic, hence stable), with a layout as follows: - * - * constants (duk_tval) - * inner functions (duk_hobject *) - * bytecode (duk_instr_t) - * - * Note: bytecode end address can be computed from 'data' buffer - * size. It is not strictly necessary functionally, assuming - * bytecode never jumps outside its allocated area. However, - * it's a safety/robustness feature for avoiding the chance of - * executing random data as bytecode due to a compiler error. - * - * Note: values in the data buffer must be incref'd (they will - * be decref'd on release) for every compiledfunction referring - * to the 'data' element. - */ - - /* Data area, fixed allocation, stable data ptrs. */ -#if defined(DUK_USE_HEAPPTR16) - duk_uint16_t data16; -#else - duk_hbuffer *data; -#endif - - /* No need for constants pointer (= same as data). - * - * When using 16-bit packing alignment to 4 is nice. 'funcs' will be - * 4-byte aligned because 'constants' are duk_tvals. For now the - * inner function pointers are not compressed, so that 'bytecode' will - * also be 4-byte aligned. - */ -#if defined(DUK_USE_HEAPPTR16) - duk_uint16_t funcs16; - duk_uint16_t bytecode16; -#else - duk_hobject **funcs; - duk_instr_t *bytecode; -#endif - - /* - * 'nregs' registers are allocated on function entry, at most 'nargs' - * are initialized to arguments, and the rest to undefined. Arguments - * above 'nregs' are not mapped to registers. All registers in the - * active stack range must be initialized because they are GC reachable. - * 'nargs' is needed so that if the function is given more than 'nargs' - * arguments, the additional arguments do not 'clobber' registers - * beyond 'nregs' which must be consistently initialized to undefined. - * - * Usually there is no need to know which registers are mapped to - * local variables. Registers may be allocated to variable in any - * way (even including gaps). However, a register-variable mapping - * must be the same for the duration of the function execution and - * the register cannot be used for anything else. - * - * When looking up variables by name, the '_Varmap' map is used. - * When an activation closes, registers mapped to arguments are - * copied into the environment record based on the same map. The - * reverse map (from register to variable) is not currently needed - * at run time, except for debugging, so it is not maintained. - */ - - duk_uint16_t nregs; /* regs to allocate */ - duk_uint16_t nargs; /* number of arguments allocated to regs */ - - /* - * Additional control information is placed into the object itself - * as internal properties to avoid unnecessary fields for the - * majority of functions. The compiler tries to omit internal - * control fields when possible. - * - * Function templates: - * - * { - * name: "func", // declaration, named function expressions - * fileName: <debug info for creating nice errors> - * _Varmap: { "arg1": 0, "arg2": 1, "varname": 2 }, - * _Formals: [ "arg1", "arg2" ], - * _Source: "function func(arg1, arg2) { ... }", - * _Pc2line: <debug info for pc-to-line mapping>, - * } - * - * Function instances: - * - * { - * length: 2, - * prototype: { constructor: <func> }, - * caller: <thrower>, - * arguments: <thrower>, - * name: "func", // declaration, named function expressions - * fileName: <debug info for creating nice errors> - * _Varmap: { "arg1": 0, "arg2": 1, "varname": 2 }, - * _Formals: [ "arg1", "arg2" ], - * _Source: "function func(arg1, arg2) { ... }", - * _Pc2line: <debug info for pc-to-line mapping>, - * _Varenv: <variable environment of closure>, - * _Lexenv: <lexical environment of closure (if differs from _Varenv)> - * } - * - * More detailed description of these properties can be found - * in the documentation. - */ - -#if defined(DUK_USE_DEBUGGER_SUPPORT) - /* Line number range for function. Needed during debugging to - * determine active breakpoints. - */ - duk_uint32_t start_line; - duk_uint32_t end_line; -#endif -}; - -#endif /* DUK_HCOMPILEDFUNCTION_H_INCLUDED */ http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/ede68a10/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap.h ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap.h b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap.h deleted file mode 100644 index 5f96b1a..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap.h +++ /dev/null @@ -1,596 +0,0 @@ -/* - * Heap structure. - * - * Heap contains allocated heap objects, interned strings, and built-in - * strings for one or more threads. - */ - -#ifndef DUK_HEAP_H_INCLUDED -#define DUK_HEAP_H_INCLUDED - -/* alloc function typedefs in duktape.h */ - -/* - * Heap flags - */ - -#define DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING (1 << 0) /* mark-and-sweep is currently running */ -#define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED (1 << 1) /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */ -#define DUK_HEAP_FLAG_REFZERO_FREE_RUNNING (1 << 2) /* refcount code is processing refzero list */ -#define DUK_HEAP_FLAG_ERRHANDLER_RUNNING (1 << 3) /* an error handler (user callback to augment/replace error) is running */ -#define DUK_HEAP_FLAG_INTERRUPT_RUNNING (1 << 4) /* executor interrupt running (used to avoid nested interrupts) */ -#define DUK_HEAP_FLAG_FINALIZER_NORESCUE (1 << 5) /* heap destruction ongoing, finalizer rescue no longer possible */ - -#define DUK__HEAP_HAS_FLAGS(heap,bits) ((heap)->flags & (bits)) -#define DUK__HEAP_SET_FLAGS(heap,bits) do { \ - (heap)->flags |= (bits); \ - } while (0) -#define DUK__HEAP_CLEAR_FLAGS(heap,bits) do { \ - (heap)->flags &= ~(bits); \ - } while (0) - -#define DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING) -#define DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) -#define DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING) -#define DUK_HEAP_HAS_ERRHANDLER_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING) -#define DUK_HEAP_HAS_INTERRUPT_RUNNING(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) -#define DUK_HEAP_HAS_FINALIZER_NORESCUE(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE) - -#define DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING) -#define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) -#define DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING) -#define DUK_HEAP_SET_ERRHANDLER_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING) -#define DUK_HEAP_SET_INTERRUPT_RUNNING(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) -#define DUK_HEAP_SET_FINALIZER_NORESCUE(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE) - -#define DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING) -#define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED) -#define DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING) -#define DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING) -#define DUK_HEAP_CLEAR_INTERRUPT_RUNNING(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING) -#define DUK_HEAP_CLEAR_FINALIZER_NORESCUE(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE) - -/* - * Longjmp types, also double as identifying continuation type for a rethrow (in 'finally') - */ - -#define DUK_LJ_TYPE_UNKNOWN 0 /* unused */ -#define DUK_LJ_TYPE_THROW 1 /* value1 -> error object */ -#define DUK_LJ_TYPE_YIELD 2 /* value1 -> yield value, iserror -> error / normal */ -#define DUK_LJ_TYPE_RESUME 3 /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */ -#define DUK_LJ_TYPE_BREAK 4 /* value1 -> label number, pseudo-type to indicate a break continuation (for ENDFIN) */ -#define DUK_LJ_TYPE_CONTINUE 5 /* value1 -> label number, pseudo-type to indicate a continue continuation (for ENDFIN) */ -#define DUK_LJ_TYPE_RETURN 6 /* value1 -> return value, pseudo-type to indicate a return continuation (for ENDFIN) */ -#define DUK_LJ_TYPE_NORMAL 7 /* no value, pseudo-type to indicate a normal continuation (for ENDFIN) */ - -/* - * Mark-and-sweep flags - * - * These are separate from heap level flags now but could be merged. - * The heap structure only contains a 'base mark-and-sweep flags' - * field and the GC caller can impose further flags. - */ - -#define DUK_MS_FLAG_EMERGENCY (1 << 0) /* emergency mode: try extra hard */ -#define DUK_MS_FLAG_NO_STRINGTABLE_RESIZE (1 << 1) /* don't resize stringtable (but may sweep it); needed during stringtable resize */ -#define DUK_MS_FLAG_NO_OBJECT_COMPACTION (1 << 2) /* don't compact objects; needed during object property allocation resize */ -#define DUK_MS_FLAG_NO_FINALIZERS (1 << 3) /* don't run finalizers; leave finalizable objects in finalize_list for next round */ -#define DUK_MS_FLAG_SKIP_FINALIZERS (1 << 4) /* don't run finalizers; queue finalizable objects back to heap_allocated */ - -/* - * Thread switching - * - * To switch heap->curr_thread, use the macro below so that interrupt counters - * get updated correctly. The macro allows a NULL target thread because that - * happens e.g. in call handling. - */ - -#if defined(DUK_USE_INTERRUPT_COUNTER) -#define DUK_HEAP_SWITCH_THREAD(heap,newthr) duk_heap_switch_thread((heap), (newthr)) -#else -#define DUK_HEAP_SWITCH_THREAD(heap,newthr) do { \ - (heap)->curr_thread = (newthr); \ - } while (0) -#endif - -/* - * Other heap related defines - */ - -/* Mark-and-sweep interval is relative to combined count of objects and - * strings kept in the heap during the latest mark-and-sweep pass. - * Fixed point .8 multiplier and .0 adder. Trigger count (interval) is - * decreased by each (re)allocation attempt (regardless of size), and each - * refzero processed object. - * - * 'SKIP' indicates how many (re)allocations to wait until a retry if - * GC is skipped because there is no thread do it with yet (happens - * only during init phases). - */ -#if defined(DUK_USE_MARK_AND_SWEEP) -#if defined(DUK_USE_REFERENCE_COUNTING) -#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT 12800L /* 50x heap size */ -#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD 1024L -#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP 256L -#else -#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT 256L /* 1x heap size */ -#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD 1024L -#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP 256L -#endif -#endif - -/* Stringcache is used for speeding up char-offset-to-byte-offset - * translations for non-ASCII strings. - */ -#define DUK_HEAP_STRCACHE_SIZE 4 -#define DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT 16 /* strings up to the this length are not cached */ - -/* helper to insert a (non-string) heap object into heap allocated list */ -#define DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap,hdr) duk_heap_insert_into_heap_allocated((heap),(hdr)) - -/* - * Stringtable - */ - -/* initial stringtable size, must be prime and higher than DUK_UTIL_MIN_HASH_PRIME */ -#define DUK_STRTAB_INITIAL_SIZE 17 - -/* indicates a deleted string; any fixed non-NULL, non-hstring pointer works */ -#define DUK_STRTAB_DELETED_MARKER(heap) ((duk_hstring *) heap) - -/* resizing parameters */ -#define DUK_STRTAB_MIN_FREE_DIVISOR 4 /* load factor max 75% */ -#define DUK_STRTAB_MIN_USED_DIVISOR 4 /* load factor min 25% */ -#define DUK_STRTAB_GROW_ST_SIZE(n) ((n) + (n)) /* used entries + approx 100% -> reset load to 50% */ - -#define DUK_STRTAB_U32_MAX_STRLEN 10 /* 4'294'967'295 */ -#define DUK_STRTAB_HIGHEST_32BIT_PRIME 0xfffffffbUL - -/* probe sequence (open addressing) */ -#define DUK_STRTAB_HASH_INITIAL(hash,h_size) ((hash) % (h_size)) -#define DUK_STRTAB_HASH_PROBE_STEP(hash) DUK_UTIL_GET_HASH_PROBE_STEP((hash)) - -/* fixed top level hashtable size (separate chaining) */ -#define DUK_STRTAB_CHAIN_SIZE DUK_USE_STRTAB_CHAIN_SIZE - -/* - * Built-in strings - */ - -/* heap string indices are autogenerated in duk_strings.h */ -#if defined(DUK_USE_ROM_STRINGS) -#define DUK_HEAP_GET_STRING(heap,idx) \ - ((duk_hstring *) DUK_LOSE_CONST(duk_rom_strings_stridx[(idx)])) -#else /* DUK_USE_ROM_STRINGS */ -#if defined(DUK_USE_HEAPPTR16) -#define DUK_HEAP_GET_STRING(heap,idx) \ - ((duk_hstring *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (heap)->strs16[(idx)])) -#else -#define DUK_HEAP_GET_STRING(heap,idx) \ - ((heap)->strs[(idx)]) -#endif -#endif /* DUK_USE_ROM_STRINGS */ - -/* - * Raw memory calls: relative to heap, but no GC interaction - */ - -#define DUK_ALLOC_RAW(heap,size) \ - ((heap)->alloc_func((heap)->heap_udata, (size))) - -#define DUK_REALLOC_RAW(heap,ptr,newsize) \ - ((heap)->realloc_func((heap)->heap_udata, (void *) (ptr), (newsize))) - -#define DUK_FREE_RAW(heap,ptr) \ - ((heap)->free_func((heap)->heap_udata, (void *) (ptr))) - -/* - * Memory calls: relative to heap, GC interaction, but no error throwing. - * - * XXX: Currently a mark-and-sweep triggered by memory allocation will run - * using the heap->heap_thread. This thread is also used for running - * mark-and-sweep finalization; this is not ideal because it breaks the - * isolation between multiple global environments. - * - * Notes: - * - * - DUK_FREE() is required to ignore NULL and any other possible return - * value of a zero-sized alloc/realloc (same as ANSI C free()). - * - * - There is no DUK_REALLOC_ZEROED because we don't assume to know the - * old size. Caller must zero the reallocated memory. - * - * - DUK_REALLOC_INDIRECT() must be used when a mark-and-sweep triggered - * by an allocation failure might invalidate the original 'ptr', thus - * causing a realloc retry to use an invalid pointer. Example: we're - * reallocating the value stack and a finalizer resizes the same value - * stack during mark-and-sweep. The indirect variant requests for the - * current location of the pointer being reallocated using a callback - * right before every realloc attempt; this circuitous approach is used - * to avoid strict aliasing issues in a more straightforward indirect - * pointer (void **) approach. Note: the pointer in the storage - * location is read but is NOT updated; the caller must do that. - */ - -/* callback for indirect reallocs, request for current pointer */ -typedef void *(*duk_mem_getptr)(duk_heap *heap, void *ud); - -#define DUK_ALLOC(heap,size) duk_heap_mem_alloc((heap), (size)) -#define DUK_ALLOC_ZEROED(heap,size) duk_heap_mem_alloc_zeroed((heap), (size)) -#define DUK_REALLOC(heap,ptr,newsize) duk_heap_mem_realloc((heap), (ptr), (newsize)) -#define DUK_REALLOC_INDIRECT(heap,cb,ud,newsize) duk_heap_mem_realloc_indirect((heap), (cb), (ud), (newsize)) -#define DUK_FREE(heap,ptr) duk_heap_mem_free((heap), (ptr)) - -/* - * Memory constants - */ - -#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT 5 /* Retry allocation after mark-and-sweep for this - * many times. A single mark-and-sweep round is - * not guaranteed to free all unreferenced memory - * because of finalization (in fact, ANY number of - * rounds is strictly not enough). - */ - -#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT 3 /* Starting from this round, use emergency mode - * for mark-and-sweep. - */ - -/* - * Debugger support - */ - -/* Maximum number of breakpoints. Only breakpoints that are set are - * consulted so increasing this has no performance impact. - */ -#define DUK_HEAP_MAX_BREAKPOINTS 16 - -/* Opcode interval for a Date-based status/peek rate limit check. Only - * relevant when debugger is attached. Requesting a timestamp may be a - * slow operation on some platforms so this shouldn't be too low. On the - * other hand a high value makes Duktape react to a pause request slowly. - */ -#define DUK_HEAP_DBG_RATELIMIT_OPCODES 4000 - -/* Milliseconds between status notify and transport peeks. */ -#define DUK_HEAP_DBG_RATELIMIT_MILLISECS 200 - -/* Step types */ -#define DUK_STEP_TYPE_NONE 0 -#define DUK_STEP_TYPE_INTO 1 -#define DUK_STEP_TYPE_OVER 2 -#define DUK_STEP_TYPE_OUT 3 - -struct duk_breakpoint { - duk_hstring *filename; - duk_uint32_t line; -}; - -#if defined(DUK_USE_DEBUGGER_SUPPORT) -#define DUK_HEAP_IS_DEBUGGER_ATTACHED(heap) ((heap)->dbg_read_cb != NULL) -#define DUK_HEAP_CLEAR_STEP_STATE(heap) do { \ - (heap)->dbg_step_type = DUK_STEP_TYPE_NONE; \ - (heap)->dbg_step_thread = NULL; \ - (heap)->dbg_step_csindex = 0; \ - (heap)->dbg_step_startline = 0; \ - } while (0) -#define DUK_HEAP_SET_PAUSED(heap) do { \ - (heap)->dbg_paused = 1; \ - (heap)->dbg_state_dirty = 1; \ - DUK_HEAP_CLEAR_STEP_STATE((heap)); \ - } while (0) -#define DUK_HEAP_CLEAR_PAUSED(heap) do { \ - (heap)->dbg_paused = 0; \ - (heap)->dbg_state_dirty = 1; \ - DUK_HEAP_CLEAR_STEP_STATE((heap)); \ - } while (0) -#define DUK_HEAP_IS_PAUSED(heap) ((heap)->dbg_paused) -#endif /* DUK_USE_DEBUGGER_SUPPORT */ - -/* - * String cache should ideally be at duk_hthread level, but that would - * cause string finalization to slow down relative to the number of - * threads; string finalization must check the string cache for "weak" - * references to the string being finalized to avoid dead pointers. - * - * Thus, string caches are now at the heap level now. - */ - -struct duk_strcache { - duk_hstring *h; - duk_uint32_t bidx; - duk_uint32_t cidx; -}; - -/* - * Longjmp state, contains the information needed to perform a longjmp. - * Longjmp related values are written to value1, value2, and iserror. - */ - -struct duk_ljstate { - duk_jmpbuf *jmpbuf_ptr; /* current setjmp() catchpoint */ - duk_small_uint_t type; /* longjmp type */ - duk_bool_t iserror; /* isError flag for yield */ - duk_tval value1; /* 1st related value (type specific) */ - duk_tval value2; /* 2nd related value (type specific) */ -}; - -/* - * Stringtable entry for fixed size stringtable - */ - -struct duk_strtab_entry { -#if defined(DUK_USE_HEAPPTR16) - /* A 16-bit listlen makes sense with 16-bit heap pointers: there - * won't be space for 64k strings anyway. - */ - duk_uint16_t listlen; /* if 0, 'str16' used, if > 0, 'strlist16' used */ - union { - duk_uint16_t strlist16; - duk_uint16_t str16; - } u; -#else - duk_size_t listlen; /* if 0, 'str' used, if > 0, 'strlist' used */ - union { - duk_hstring **strlist; - duk_hstring *str; - } u; -#endif -}; - -/* - * Main heap structure - */ - -struct duk_heap { - duk_small_uint_t flags; - - /* Allocator functions. */ - duk_alloc_function alloc_func; - duk_realloc_function realloc_func; - duk_free_function free_func; - - /* Heap udata, used for allocator functions but also for other heap - * level callbacks like pointer compression, etc. - */ - void *heap_udata; - - /* Precomputed pointers when using 16-bit heap pointer packing. */ -#if defined(DUK_USE_HEAPPTR16) - duk_uint16_t heapptr_null16; - duk_uint16_t heapptr_deleted16; -#endif - - /* Fatal error handling, called e.g. when a longjmp() is needed but - * lj.jmpbuf_ptr is NULL. fatal_func must never return; it's not - * declared as "noreturn" because doing that for typedefs is a bit - * challenging portability-wise. - */ - duk_fatal_function fatal_func; - - /* allocated heap objects */ - duk_heaphdr *heap_allocated; - - /* work list for objects whose refcounts are zero but which have not been - * "finalized"; avoids recursive C calls when refcounts go to zero in a - * chain of objects. - */ -#if defined(DUK_USE_REFERENCE_COUNTING) - duk_heaphdr *refzero_list; - duk_heaphdr *refzero_list_tail; -#endif - -#if defined(DUK_USE_MARK_AND_SWEEP) - /* mark-and-sweep control */ -#if defined(DUK_USE_VOLUNTARY_GC) - duk_int_t mark_and_sweep_trigger_counter; -#endif - duk_int_t mark_and_sweep_recursion_depth; - - /* mark-and-sweep flags automatically active (used for critical sections) */ - duk_small_uint_t mark_and_sweep_base_flags; - - /* work list for objects to be finalized (by mark-and-sweep) */ - duk_heaphdr *finalize_list; -#endif - - /* longjmp state */ - duk_ljstate lj; - - /* marker for detecting internal "double faults", see duk_error_throw.c */ - duk_bool_t handling_error; - - /* heap thread, used internally and for finalization */ - duk_hthread *heap_thread; - - /* current thread */ - duk_hthread *curr_thread; /* currently running thread */ - - /* heap level "stash" object (e.g., various reachability roots) */ - duk_hobject *heap_object; - - /* duk_handle_call / duk_handle_safe_call recursion depth limiting */ - duk_int_t call_recursion_depth; - duk_int_t call_recursion_limit; - - /* mix-in value for computing string hashes; should be reasonably unpredictable */ - duk_uint32_t hash_seed; - - /* rnd_state for duk_util_tinyrandom.c */ - duk_uint32_t rnd_state; - - /* For manual debugging: instruction count based on executor and - * interrupt counter book-keeping. Inspect debug logs to see how - * they match up. - */ -#if defined(DUK_USE_INTERRUPT_COUNTER) && defined(DUK_USE_DEBUG) - duk_int_t inst_count_exec; - duk_int_t inst_count_interrupt; -#endif - - /* debugger */ - -#if defined(DUK_USE_DEBUGGER_SUPPORT) - /* callbacks and udata; dbg_read_cb != NULL is used to indicate attached state */ - duk_debug_read_function dbg_read_cb; /* required, NULL implies detached */ - duk_debug_write_function dbg_write_cb; /* required */ - duk_debug_peek_function dbg_peek_cb; - duk_debug_read_flush_function dbg_read_flush_cb; - duk_debug_write_flush_function dbg_write_flush_cb; - duk_debug_request_function dbg_request_cb; - duk_debug_detached_function dbg_detached_cb; - void *dbg_udata; - - /* debugger state, only relevant when attached */ - duk_bool_t dbg_processing; /* currently processing messages or breakpoints: don't enter message processing recursively (e.g. no breakpoints when processing debugger eval) */ - duk_bool_t dbg_paused; /* currently paused: talk with debug client until step/resume */ - duk_bool_t dbg_state_dirty; /* resend state next time executor is about to run */ - duk_bool_t dbg_force_restart; /* force executor restart to recheck breakpoints; used to handle function returns (see GH-303) */ - duk_bool_t dbg_detaching; /* debugger detaching; used to avoid calling detach handler recursively */ - duk_small_uint_t dbg_step_type; /* step type: none, step into, step over, step out */ - duk_hthread *dbg_step_thread; /* borrowed; NULL if no step state (NULLed in unwind) */ - duk_size_t dbg_step_csindex; /* callstack index */ - duk_uint32_t dbg_step_startline; /* starting line number */ - duk_breakpoint dbg_breakpoints[DUK_HEAP_MAX_BREAKPOINTS]; /* breakpoints: [0,breakpoint_count[ gc reachable */ - duk_small_uint_t dbg_breakpoint_count; - duk_breakpoint *dbg_breakpoints_active[DUK_HEAP_MAX_BREAKPOINTS + 1]; /* currently active breakpoints: NULL term, borrowed pointers */ - /* XXX: make active breakpoints actual copies instead of pointers? */ - - /* These are for rate limiting Status notifications and transport peeking. */ - duk_uint32_t dbg_exec_counter; /* cumulative opcode execution count (overflows are OK) */ - duk_uint32_t dbg_last_counter; /* value of dbg_exec_counter when we last did a Date-based check */ - duk_double_t dbg_last_time; /* time when status/peek was last done (Date-based rate limit) */ - - /* Used to support single-byte stream lookahead. */ - duk_bool_t dbg_have_next_byte; - duk_uint8_t dbg_next_byte; -#endif - - /* string intern table (weak refs) */ -#if defined(DUK_USE_STRTAB_PROBE) -#if defined(DUK_USE_HEAPPTR16) - duk_uint16_t *strtable16; -#else - duk_hstring **strtable; -#endif - duk_uint32_t st_size; /* alloc size in elements */ - duk_uint32_t st_used; /* used elements (includes DELETED) */ -#endif - - /* XXX: static alloc is OK until separate chaining stringtable - * resizing is implemented. - */ -#if defined(DUK_USE_STRTAB_CHAIN) - duk_strtab_entry strtable[DUK_STRTAB_CHAIN_SIZE]; -#endif - - /* string access cache (codepoint offset -> byte offset) for fast string - * character looping; 'weak' reference which needs special handling in GC. - */ - duk_strcache strcache[DUK_HEAP_STRCACHE_SIZE]; - - /* built-in strings */ -#if defined(DUK_USE_ROM_STRINGS) - /* No field needed when strings are in ROM. */ -#else -#if defined(DUK_USE_HEAPPTR16) - duk_uint16_t strs16[DUK_HEAP_NUM_STRINGS]; -#else - duk_hstring *strs[DUK_HEAP_NUM_STRINGS]; -#endif -#endif -}; - -/* - * Prototypes - */ - -DUK_INTERNAL_DECL -duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, - duk_realloc_function realloc_func, - duk_free_function free_func, - void *heap_udata, - duk_fatal_function fatal_func); -DUK_INTERNAL_DECL void duk_heap_free(duk_heap *heap); -DUK_INTERNAL_DECL void duk_free_hobject_inner(duk_heap *heap, duk_hobject *h); -DUK_INTERNAL_DECL void duk_free_hbuffer_inner(duk_heap *heap, duk_hbuffer *h); -DUK_INTERNAL_DECL void duk_free_hstring_inner(duk_heap *heap, duk_hstring *h); -DUK_INTERNAL_DECL void duk_heap_free_heaphdr_raw(duk_heap *heap, duk_heaphdr *hdr); - -DUK_INTERNAL_DECL void duk_heap_insert_into_heap_allocated(duk_heap *heap, duk_heaphdr *hdr); -#if defined(DUK_USE_DOUBLE_LINKED_HEAP) && defined(DUK_USE_REFERENCE_COUNTING) -DUK_INTERNAL_DECL void duk_heap_remove_any_from_heap_allocated(duk_heap *heap, duk_heaphdr *hdr); -#endif -#if defined(DUK_USE_INTERRUPT_COUNTER) -DUK_INTERNAL_DECL void duk_heap_switch_thread(duk_heap *heap, duk_hthread *new_thr); -#endif - -#if 0 /*unused*/ -DUK_INTERNAL_DECL duk_hstring *duk_heap_string_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen); -#endif -DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen); -DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_checked(duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t len); -#if 0 /*unused*/ -DUK_INTERNAL_DECL duk_hstring *duk_heap_string_lookup_u32(duk_heap *heap, duk_uint32_t val); -#endif -DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_u32(duk_heap *heap, duk_uint32_t val); -DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_u32_checked(duk_hthread *thr, duk_uint32_t val); -#if defined(DUK_USE_REFERENCE_COUNTING) -DUK_INTERNAL_DECL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h); -#endif -#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_MS_STRINGTABLE_RESIZE) -DUK_INTERNAL_DECL void duk_heap_force_strtab_resize(duk_heap *heap); -#endif -DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap); -#if defined(DUK_USE_DEBUG) -DUK_INTERNAL void duk_heap_dump_strtab(duk_heap *heap); -#endif - - -DUK_INTERNAL_DECL void duk_heap_strcache_string_remove(duk_heap *heap, duk_hstring *h); -DUK_INTERNAL_DECL duk_uint_fast32_t duk_heap_strcache_offset_char2byte(duk_hthread *thr, duk_hstring *h, duk_uint_fast32_t char_offset); - -#if defined(DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS) -DUK_INTERNAL_DECL void *duk_default_alloc_function(void *udata, duk_size_t size); -DUK_INTERNAL_DECL void *duk_default_realloc_function(void *udata, void *ptr, duk_size_t newsize); -DUK_INTERNAL_DECL void duk_default_free_function(void *udata, void *ptr); -#endif - -DUK_INTERNAL_DECL void *duk_heap_mem_alloc(duk_heap *heap, duk_size_t size); -DUK_INTERNAL_DECL void *duk_heap_mem_alloc_zeroed(duk_heap *heap, duk_size_t size); -DUK_INTERNAL_DECL void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize); -DUK_INTERNAL_DECL void *duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize); -DUK_INTERNAL_DECL void duk_heap_mem_free(duk_heap *heap, void *ptr); - -#ifdef DUK_USE_REFERENCE_COUNTING -#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT) -DUK_INTERNAL_DECL void duk_tval_incref(duk_tval *tv); -#endif -#if 0 /* unused */ -DUK_INTERNAL_DECL void duk_tval_incref_allownull(duk_tval *tv); -#endif -DUK_INTERNAL_DECL void duk_tval_decref(duk_hthread *thr, duk_tval *tv); -#if 0 /* unused */ -DUK_INTERNAL_DECL void duk_tval_decref_allownull(duk_hthread *thr, duk_tval *tv); -#endif -#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT) -DUK_INTERNAL_DECL void duk_heaphdr_incref(duk_heaphdr *h); -#endif -#if 0 /* unused */ -DUK_INTERNAL_DECL void duk_heaphdr_incref_allownull(duk_heaphdr *h); -#endif -DUK_INTERNAL_DECL void duk_heaphdr_decref(duk_hthread *thr, duk_heaphdr *h); -DUK_INTERNAL_DECL void duk_heaphdr_decref_allownull(duk_hthread *thr, duk_heaphdr *h); -DUK_INTERNAL_DECL void duk_heaphdr_refzero(duk_hthread *thr, duk_heaphdr *h); -DUK_INTERNAL_DECL void duk_heaphdr_refcount_finalize(duk_hthread *thr, duk_heaphdr *hdr); -#else -/* no refcounting */ -#endif - -#if defined(DUK_USE_MARK_AND_SWEEP) -DUK_INTERNAL_DECL duk_bool_t duk_heap_mark_and_sweep(duk_heap *heap, duk_small_uint_t flags); -#endif - -DUK_INTERNAL_DECL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uint8_t *str, duk_size_t len); - -#endif /* DUK_HEAP_H_INCLUDED */ http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/ede68a10/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap_alloc.c ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap_alloc.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap_alloc.c deleted file mode 100644 index b89fe48..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap_alloc.c +++ /dev/null @@ -1,1042 +0,0 @@ -/* - * duk_heap allocation and freeing. - */ - -#include "duk_internal.h" - -/* Constants for built-in string data depacking. */ -#define DUK__BITPACK_LETTER_LIMIT 26 -#define DUK__BITPACK_UNDERSCORE 26 -#define DUK__BITPACK_FF 27 -#define DUK__BITPACK_SWITCH1 29 -#define DUK__BITPACK_SWITCH 30 -#define DUK__BITPACK_SEVENBIT 31 - -#if defined(DUK_USE_ROM_STRINGS) -/* Fixed seed value used with ROM strings. */ -#define DUK__FIXED_HASH_SEED 0xabcd1234 -#endif - -/* - * Free a heap object. - * - * Free heap object and its internal (non-heap) pointers. Assumes that - * caller has removed the object from heap allocated list or the string - * intern table, and any weak references (which strings may have) have - * been already dealt with. - */ - -DUK_INTERNAL void duk_free_hobject_inner(duk_heap *heap, duk_hobject *h) { - DUK_ASSERT(heap != NULL); - DUK_ASSERT(h != NULL); - - DUK_FREE(heap, DUK_HOBJECT_GET_PROPS(heap, h)); - - if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) { - duk_hcompiledfunction *f = (duk_hcompiledfunction *) h; - DUK_UNREF(f); - /* Currently nothing to free; 'data' is a heap object */ - } else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) { - duk_hnativefunction *f = (duk_hnativefunction *) h; - DUK_UNREF(f); - /* Currently nothing to free */ - } else if (DUK_HOBJECT_IS_THREAD(h)) { - duk_hthread *t = (duk_hthread *) h; - DUK_FREE(heap, t->valstack); - DUK_FREE(heap, t->callstack); - DUK_FREE(heap, t->catchstack); - /* Don't free h->resumer because it exists in the heap. - * Callstack entries also contain function pointers which - * are not freed for the same reason. - */ - - /* XXX: with 'caller' property the callstack would need - * to be unwound to update the 'caller' properties of - * functions in the callstack. - */ - } -} - -DUK_INTERNAL void duk_free_hbuffer_inner(duk_heap *heap, duk_hbuffer *h) { - DUK_ASSERT(heap != NULL); - DUK_ASSERT(h != NULL); - - if (DUK_HBUFFER_HAS_DYNAMIC(h) && !DUK_HBUFFER_HAS_EXTERNAL(h)) { - duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h; - DUK_DDD(DUK_DDDPRINT("free dynamic buffer %p", (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g))); - DUK_FREE(heap, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g)); - } -} - -DUK_INTERNAL void duk_free_hstring_inner(duk_heap *heap, duk_hstring *h) { - DUK_ASSERT(heap != NULL); - DUK_ASSERT(h != NULL); - - DUK_UNREF(heap); - DUK_UNREF(h); - -#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_FREE) - if (DUK_HSTRING_HAS_EXTDATA(h)) { - DUK_DDD(DUK_DDDPRINT("free extstr: hstring %!O, extdata: %p", - h, DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h))); - DUK_USE_EXTSTR_FREE(heap->heap_udata, (const void *) DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h)); - } -#endif -} - -DUK_INTERNAL void duk_heap_free_heaphdr_raw(duk_heap *heap, duk_heaphdr *hdr) { - DUK_ASSERT(heap); - DUK_ASSERT(hdr); - - DUK_DDD(DUK_DDDPRINT("free heaphdr %p, htype %ld", (void *) hdr, (long) DUK_HEAPHDR_GET_TYPE(hdr))); - - switch ((int) DUK_HEAPHDR_GET_TYPE(hdr)) { - case DUK_HTYPE_STRING: - duk_free_hstring_inner(heap, (duk_hstring *) hdr); - break; - case DUK_HTYPE_OBJECT: - duk_free_hobject_inner(heap, (duk_hobject *) hdr); - break; - case DUK_HTYPE_BUFFER: - duk_free_hbuffer_inner(heap, (duk_hbuffer *) hdr); - break; - default: - DUK_UNREACHABLE(); - } - - DUK_FREE(heap, hdr); -} - -/* - * Free the heap. - * - * Frees heap-related non-heap-tracked allocations such as the - * string intern table; then frees the heap allocated objects; - * and finally frees the heap structure itself. Reference counts - * and GC markers are ignored (and not updated) in this process, - * and finalizers won't be called. - * - * The heap pointer and heap object pointers must not be used - * after this call. - */ - -DUK_LOCAL void duk__free_allocated(duk_heap *heap) { - duk_heaphdr *curr; - duk_heaphdr *next; - - curr = heap->heap_allocated; - while (curr) { - /* We don't log or warn about freeing zero refcount objects - * because they may happen with finalizer processing. - */ - - DUK_DDD(DUK_DDDPRINT("FINALFREE (allocated): %!iO", - (duk_heaphdr *) curr)); - next = DUK_HEAPHDR_GET_NEXT(heap, curr); - duk_heap_free_heaphdr_raw(heap, curr); - curr = next; - } -} - -#if defined(DUK_USE_REFERENCE_COUNTING) -DUK_LOCAL void duk__free_refzero_list(duk_heap *heap) { - duk_heaphdr *curr; - duk_heaphdr *next; - - curr = heap->refzero_list; - while (curr) { - DUK_DDD(DUK_DDDPRINT("FINALFREE (refzero_list): %!iO", - (duk_heaphdr *) curr)); - next = DUK_HEAPHDR_GET_NEXT(heap, curr); - duk_heap_free_heaphdr_raw(heap, curr); - curr = next; - } -} -#endif - -#if defined(DUK_USE_MARK_AND_SWEEP) -DUK_LOCAL void duk__free_markandsweep_finalize_list(duk_heap *heap) { - duk_heaphdr *curr; - duk_heaphdr *next; - - curr = heap->finalize_list; - while (curr) { - DUK_DDD(DUK_DDDPRINT("FINALFREE (finalize_list): %!iO", - (duk_heaphdr *) curr)); - next = DUK_HEAPHDR_GET_NEXT(heap, curr); - duk_heap_free_heaphdr_raw(heap, curr); - curr = next; - } -} -#endif - -DUK_LOCAL void duk__free_stringtable(duk_heap *heap) { - /* strings are only tracked by stringtable */ - duk_heap_free_strtab(heap); -} - -DUK_LOCAL void duk__free_run_finalizers(duk_heap *heap) { - duk_hthread *thr; - duk_heaphdr *curr; - duk_uint_t round_no; - duk_size_t count_all; - duk_size_t count_finalized; - duk_size_t curr_limit; - - DUK_ASSERT(heap != NULL); - DUK_ASSERT(heap->heap_thread != NULL); - -#if defined(DUK_USE_REFERENCE_COUNTING) - DUK_ASSERT(heap->refzero_list == NULL); /* refzero not running -> must be empty */ -#endif -#if defined(DUK_USE_MARK_AND_SWEEP) - DUK_ASSERT(heap->finalize_list == NULL); /* mark-and-sweep not running -> must be empty */ -#endif - - /* XXX: here again finalizer thread is the heap_thread which needs - * to be coordinated with finalizer thread fixes. - */ - thr = heap->heap_thread; - DUK_ASSERT(thr != NULL); - - /* Prevent mark-and-sweep for the pending finalizers, also prevents - * refzero handling from moving objects away from the heap_allocated - * list. (The flag meaning is slightly abused here.) - */ - DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)); - DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap); - - curr_limit = 0; /* suppress warning, not used */ - for (round_no = 0; ; round_no++) { - curr = heap->heap_allocated; - count_all = 0; - count_finalized = 0; - while (curr) { - count_all++; - if (DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT) { - /* Only objects in heap_allocated may have finalizers. Check that - * the object itself has a _Finalizer property (own or inherited) - * so that we don't execute finalizers for e.g. Proxy objects. - */ - DUK_ASSERT(thr != NULL); - DUK_ASSERT(curr != NULL); - - if (duk_hobject_hasprop_raw(thr, (duk_hobject *) curr, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) { - if (!DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) curr)) { - DUK_ASSERT(DUK_HEAP_HAS_FINALIZER_NORESCUE(heap)); /* maps to finalizer 2nd argument */ - duk_hobject_run_finalizer(thr, (duk_hobject *) curr); - count_finalized++; - } - } - } - curr = DUK_HEAPHDR_GET_NEXT(heap, curr); - } - - /* Each round of finalizer execution may spawn new finalizable objects - * which is normal behavior for some applications. Allow multiple - * rounds of finalization, but use a shrinking limit based on the - * first round to detect the case where a runaway finalizer creates - * an unbounded amount of new finalizable objects. Finalizer rescue - * is not supported: the semantics are unclear because most of the - * objects being finalized here are already reachable. The finalizer - * is given a boolean to indicate that rescue is not possible. - * - * See discussion in: https://github.com/svaarala/duktape/pull/473 - */ - - if (round_no == 0) { - /* Cannot wrap: each object is at least 8 bytes so count is - * at most 1/8 of that. - */ - curr_limit = count_all * 2; - } else { - curr_limit = (curr_limit * 3) / 4; /* Decrease by 25% every round */ - } - DUK_D(DUK_DPRINT("finalizer round %ld complete, %ld objects, tried to execute %ld finalizers, current limit is %ld", - (long) round_no, (long) count_all, (long) count_finalized, (long) curr_limit)); - - if (count_finalized == 0) { - DUK_D(DUK_DPRINT("no more finalizable objects, forced finalization finished")); - break; - } - if (count_finalized >= curr_limit) { - DUK_D(DUK_DPRINT("finalizer count above limit, potentially runaway finalizer; skip remaining finalizers")); - break; - } - } - - DUK_ASSERT(DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)); - DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap); -} - -DUK_INTERNAL void duk_heap_free(duk_heap *heap) { - DUK_D(DUK_DPRINT("free heap: %p", (void *) heap)); - -#if defined(DUK_USE_DEBUG) - duk_heap_dump_strtab(heap); -#endif - -#if defined(DUK_USE_DEBUGGER_SUPPORT) - /* Detach a debugger if attached (can be called multiple times) - * safely. - */ - /* XXX: Add a flag to reject an attempt to re-attach? Otherwise - * the detached callback may immediately reattach. - */ - duk_debug_do_detach(heap); -#endif - - /* Execute finalizers before freeing the heap, even for reachable - * objects, and regardless of whether or not mark-and-sweep is - * enabled. This gives finalizers the chance to free any native - * resources like file handles, allocations made outside Duktape, - * etc. This is quite tricky to get right, so that all finalizer - * guarantees are honored. - * - * XXX: this perhaps requires an execution time limit. - */ - DUK_D(DUK_DPRINT("execute finalizers before freeing heap")); -#if defined(DUK_USE_MARK_AND_SWEEP) - /* Run mark-and-sweep a few times just in case (unreachable object - * finalizers run already here). The last round must rescue objects - * from the previous round without running any more finalizers. This - * ensures rescued objects get their FINALIZED flag cleared so that - * their finalizer is called once more in forced finalization to - * satisfy finalizer guarantees. However, we don't want to run any - * more finalizer because that'd required one more loop, and so on. - */ - DUK_D(DUK_DPRINT("forced gc #1 in heap destruction")); - duk_heap_mark_and_sweep(heap, 0); - DUK_D(DUK_DPRINT("forced gc #2 in heap destruction")); - duk_heap_mark_and_sweep(heap, 0); - DUK_D(DUK_DPRINT("forced gc #3 in heap destruction (don't run finalizers)")); - duk_heap_mark_and_sweep(heap, DUK_MS_FLAG_SKIP_FINALIZERS); /* skip finalizers; queue finalizable objects to heap_allocated */ -#endif - - DUK_HEAP_SET_FINALIZER_NORESCUE(heap); /* rescue no longer supported */ - duk__free_run_finalizers(heap); - - /* Note: heap->heap_thread, heap->curr_thread, and heap->heap_object - * are on the heap allocated list. - */ - - DUK_D(DUK_DPRINT("freeing heap objects of heap: %p", (void *) heap)); - duk__free_allocated(heap); - -#if defined(DUK_USE_REFERENCE_COUNTING) - DUK_D(DUK_DPRINT("freeing refzero list of heap: %p", (void *) heap)); - duk__free_refzero_list(heap); -#endif - -#if defined(DUK_USE_MARK_AND_SWEEP) - DUK_D(DUK_DPRINT("freeing mark-and-sweep finalize list of heap: %p", (void *) heap)); - duk__free_markandsweep_finalize_list(heap); -#endif - - DUK_D(DUK_DPRINT("freeing string table of heap: %p", (void *) heap)); - duk__free_stringtable(heap); - - DUK_D(DUK_DPRINT("freeing heap structure: %p", (void *) heap)); - heap->free_func(heap->heap_udata, heap); -} - -/* - * Allocate a heap. - * - * String table is initialized with built-in strings from genbuiltins.py, - * either by dynamically creating the strings or by referring to ROM strings. - */ - -#if defined(DUK_USE_ROM_STRINGS) -DUK_LOCAL duk_bool_t duk__init_heap_strings(duk_heap *heap) { -#if defined(DUK_USE_ASSERTIONS) - duk_small_uint_t i; -#endif - - /* With ROM-based strings, heap->strs[] and thr->strs[] are omitted - * so nothing to initialize for strs[]. - */ - -#if defined(DUK_USE_ASSERTIONS) - for (i = 0; i < sizeof(duk_rom_strings) / sizeof(const duk_hstring *); i++) { - duk_uint32_t hash; - const duk_hstring *h; - h = duk_rom_strings[i]; - DUK_ASSERT(h != NULL); - hash = duk_heap_hashstring(heap, (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h)); - DUK_DD(DUK_DDPRINT("duk_rom_strings[%d] -> hash 0x%08lx, computed 0x%08lx", - (int) i, (unsigned long) DUK_HSTRING_GET_HASH(h), (unsigned long) hash)); - DUK_ASSERT(hash == (duk_uint32_t) DUK_HSTRING_GET_HASH(h)); - } -#endif - return 1; -} -#else /* DUK_USE_ROM_STRINGS */ -DUK_LOCAL duk_bool_t duk__init_heap_strings(duk_heap *heap) { - duk_bitdecoder_ctx bd_ctx; - duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */ - duk_small_uint_t i, j; - - DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx)); - bd->data = (const duk_uint8_t *) duk_strings_data; - bd->length = (duk_size_t) DUK_STRDATA_DATA_LENGTH; - - for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) { - duk_uint8_t tmp[DUK_STRDATA_MAX_STRLEN]; - duk_hstring *h; - duk_small_uint_t len; - duk_small_uint_t mode; - duk_small_uint_t t; - - len = duk_bd_decode(bd, 5); - mode = 32; /* 0 = uppercase, 32 = lowercase (= 'a' - 'A') */ - for (j = 0; j < len; j++) { - t = duk_bd_decode(bd, 5); - if (t < DUK__BITPACK_LETTER_LIMIT) { - t = t + DUK_ASC_UC_A + mode; - } else if (t == DUK__BITPACK_UNDERSCORE) { - t = DUK_ASC_UNDERSCORE; - } else if (t == DUK__BITPACK_FF) { - /* Internal keys are prefixed with 0xFF in the stringtable - * (which makes them invalid UTF-8 on purpose). - */ - t = 0xff; - } else if (t == DUK__BITPACK_SWITCH1) { - t = duk_bd_decode(bd, 5); - DUK_ASSERT_DISABLE(t >= 0); /* unsigned */ - DUK_ASSERT(t <= 25); - t = t + DUK_ASC_UC_A + (mode ^ 32); - } else if (t == DUK__BITPACK_SWITCH) { - mode = mode ^ 32; - t = duk_bd_decode(bd, 5); - DUK_ASSERT_DISABLE(t >= 0); - DUK_ASSERT(t <= 25); - t = t + DUK_ASC_UC_A + mode; - } else if (t == DUK__BITPACK_SEVENBIT) { - t = duk_bd_decode(bd, 7); - } - tmp[j] = (duk_uint8_t) t; - } - - /* No need to length check string: it will never exceed even - * the 16-bit length maximum. - */ - DUK_ASSERT(len <= 0xffffUL); - DUK_DDD(DUK_DDDPRINT("intern built-in string %ld", (long) i)); - h = duk_heap_string_intern(heap, tmp, len); - if (!h) { - goto error; - } - DUK_ASSERT(!DUK_HEAPHDR_HAS_READONLY((duk_heaphdr *) h)); - - /* Special flags checks. Since these strings are always - * reachable and a string cannot appear twice in the string - * table, there's no need to check/set these flags elsewhere. - * The 'internal' flag is set by string intern code. - */ - if (i == DUK_STRIDX_EVAL || i == DUK_STRIDX_LC_ARGUMENTS) { - DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(h); - } - if (i >= DUK_STRIDX_START_RESERVED && i < DUK_STRIDX_END_RESERVED) { - DUK_HSTRING_SET_RESERVED_WORD(h); - if (i >= DUK_STRIDX_START_STRICT_RESERVED) { - DUK_HSTRING_SET_STRICT_RESERVED_WORD(h); - } - } - - DUK_DDD(DUK_DDDPRINT("interned: %!O", (duk_heaphdr *) h)); - - /* XXX: The incref macro takes a thread pointer but doesn't - * use it right now. - */ - DUK_HSTRING_INCREF(_never_referenced_, h); - -#if defined(DUK_USE_HEAPPTR16) - heap->strs16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h); -#else - heap->strs[i] = h; -#endif - } - - return 1; - - error: - return 0; -} -#endif /* DUK_USE_ROM_STRINGS */ - -DUK_LOCAL duk_bool_t duk__init_heap_thread(duk_heap *heap) { - duk_hthread *thr; - - DUK_DD(DUK_DDPRINT("heap init: alloc heap thread")); - thr = duk_hthread_alloc(heap, - DUK_HOBJECT_FLAG_EXTENSIBLE | - DUK_HOBJECT_FLAG_THREAD | - DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_THREAD)); - if (!thr) { - DUK_D(DUK_DPRINT("failed to alloc heap_thread")); - return 0; - } - thr->state = DUK_HTHREAD_STATE_INACTIVE; -#if defined(DUK_USE_ROM_STRINGS) - /* No strs[] pointer. */ -#else /* DUK_USE_ROM_STRINGS */ -#if defined(DUK_USE_HEAPPTR16) - thr->strs16 = heap->strs16; -#else - thr->strs = heap->strs; -#endif -#endif /* DUK_USE_ROM_STRINGS */ - - heap->heap_thread = thr; - DUK_HTHREAD_INCREF(thr, thr); /* Note: first argument not really used */ - - /* 'thr' is now reachable */ - - if (!duk_hthread_init_stacks(heap, thr)) { - return 0; - } - - /* XXX: this may now fail, and is not handled correctly */ - duk_hthread_create_builtin_objects(thr); - - /* default prototype (Note: 'thr' must be reachable) */ - DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) thr, thr->builtins[DUK_BIDX_THREAD_PROTOTYPE]); - - return 1; -} - -#if defined(DUK_USE_DEBUG) -#define DUK__DUMPSZ(t) do { \ - DUK_D(DUK_DPRINT("" #t "=%ld", (long) sizeof(t))); \ - } while (0) - -/* These is not 100% because format would need to be non-portable "long long". - * Also print out as doubles to catch cases where the "long" type is not wide - * enough; the limits will then not be printed accurately but the magnitude - * will be correct. - */ -#define DUK__DUMPLM_SIGNED_RAW(t,a,b) do { \ - DUK_D(DUK_DPRINT(t "=[%ld,%ld]=[%lf,%lf]", \ - (long) (a), (long) (b), \ - (double) (a), (double) (b))); \ - } while (0) -#define DUK__DUMPLM_UNSIGNED_RAW(t,a,b) do { \ - DUK_D(DUK_DPRINT(t "=[%lu,%lu]=[%lf,%lf]", \ - (unsigned long) (a), (unsigned long) (b), \ - (double) (a), (double) (b))); \ - } while (0) -#define DUK__DUMPLM_SIGNED(t) do { \ - DUK__DUMPLM_SIGNED_RAW("DUK_" #t "_{MIN,MAX}", DUK_##t##_MIN, DUK_##t##_MAX); \ - } while (0) -#define DUK__DUMPLM_UNSIGNED(t) do { \ - DUK__DUMPLM_UNSIGNED_RAW("DUK_" #t "_{MIN,MAX}", DUK_##t##_MIN, DUK_##t##_MAX); \ - } while (0) - -DUK_LOCAL void duk__dump_type_sizes(void) { - DUK_D(DUK_DPRINT("sizeof()")); - - /* basic platform types */ - DUK__DUMPSZ(char); - DUK__DUMPSZ(short); - DUK__DUMPSZ(int); - DUK__DUMPSZ(long); - DUK__DUMPSZ(double); - DUK__DUMPSZ(void *); - DUK__DUMPSZ(size_t); - - /* basic types from duk_features.h */ - DUK__DUMPSZ(duk_uint8_t); - DUK__DUMPSZ(duk_int8_t); - DUK__DUMPSZ(duk_uint16_t); - DUK__DUMPSZ(duk_int16_t); - DUK__DUMPSZ(duk_uint32_t); - DUK__DUMPSZ(duk_int32_t); - DUK__DUMPSZ(duk_uint64_t); - DUK__DUMPSZ(duk_int64_t); - DUK__DUMPSZ(duk_uint_least8_t); - DUK__DUMPSZ(duk_int_least8_t); - DUK__DUMPSZ(duk_uint_least16_t); - DUK__DUMPSZ(duk_int_least16_t); - DUK__DUMPSZ(duk_uint_least32_t); - DUK__DUMPSZ(duk_int_least32_t); -#if defined(DUK_USE_64BIT_OPS) - DUK__DUMPSZ(duk_uint_least64_t); - DUK__DUMPSZ(duk_int_least64_t); -#endif - DUK__DUMPSZ(duk_uint_fast8_t); - DUK__DUMPSZ(duk_int_fast8_t); - DUK__DUMPSZ(duk_uint_fast16_t); - DUK__DUMPSZ(duk_int_fast16_t); - DUK__DUMPSZ(duk_uint_fast32_t); - DUK__DUMPSZ(duk_int_fast32_t); -#if defined(DUK_USE_64BIT_OPS) - DUK__DUMPSZ(duk_uint_fast64_t); - DUK__DUMPSZ(duk_int_fast64_t); -#endif - DUK__DUMPSZ(duk_uintptr_t); - DUK__DUMPSZ(duk_intptr_t); - DUK__DUMPSZ(duk_uintmax_t); - DUK__DUMPSZ(duk_intmax_t); - DUK__DUMPSZ(duk_double_t); - - /* important chosen base types */ - DUK__DUMPSZ(duk_int_t); - DUK__DUMPSZ(duk_uint_t); - DUK__DUMPSZ(duk_int_fast_t); - DUK__DUMPSZ(duk_uint_fast_t); - DUK__DUMPSZ(duk_small_int_t); - DUK__DUMPSZ(duk_small_uint_t); - DUK__DUMPSZ(duk_small_int_fast_t); - DUK__DUMPSZ(duk_small_uint_fast_t); - - /* some derived types */ - DUK__DUMPSZ(duk_codepoint_t); - DUK__DUMPSZ(duk_ucodepoint_t); - DUK__DUMPSZ(duk_idx_t); - DUK__DUMPSZ(duk_errcode_t); - DUK__DUMPSZ(duk_uarridx_t); - - /* tval */ - DUK__DUMPSZ(duk_double_union); - DUK__DUMPSZ(duk_tval); - - /* structs from duk_forwdecl.h */ - DUK__DUMPSZ(duk_jmpbuf); /* just one 'int' for C++ exceptions */ - DUK__DUMPSZ(duk_heaphdr); - DUK__DUMPSZ(duk_heaphdr_string); - DUK__DUMPSZ(duk_hstring); - DUK__DUMPSZ(duk_hstring_external); - DUK__DUMPSZ(duk_hobject); - DUK__DUMPSZ(duk_hcompiledfunction); - DUK__DUMPSZ(duk_hnativefunction); - DUK__DUMPSZ(duk_hthread); - DUK__DUMPSZ(duk_hbuffer); - DUK__DUMPSZ(duk_hbuffer_fixed); - DUK__DUMPSZ(duk_hbuffer_dynamic); - DUK__DUMPSZ(duk_hbuffer_external); - DUK__DUMPSZ(duk_propaccessor); - DUK__DUMPSZ(duk_propvalue); - DUK__DUMPSZ(duk_propdesc); - DUK__DUMPSZ(duk_heap); -#if defined(DUK_USE_STRTAB_CHAIN) - DUK__DUMPSZ(duk_strtab_entry); -#endif - DUK__DUMPSZ(duk_activation); - DUK__DUMPSZ(duk_catcher); - DUK__DUMPSZ(duk_strcache); - DUK__DUMPSZ(duk_ljstate); - DUK__DUMPSZ(duk_fixedbuffer); - DUK__DUMPSZ(duk_bitdecoder_ctx); - DUK__DUMPSZ(duk_bitencoder_ctx); - DUK__DUMPSZ(duk_token); - DUK__DUMPSZ(duk_re_token); - DUK__DUMPSZ(duk_lexer_point); - DUK__DUMPSZ(duk_lexer_ctx); - DUK__DUMPSZ(duk_compiler_instr); - DUK__DUMPSZ(duk_compiler_func); - DUK__DUMPSZ(duk_compiler_ctx); - DUK__DUMPSZ(duk_re_matcher_ctx); - DUK__DUMPSZ(duk_re_compiler_ctx); -} -DUK_LOCAL void duk__dump_type_limits(void) { - DUK_D(DUK_DPRINT("limits")); - - /* basic types */ - DUK__DUMPLM_SIGNED(INT8); - DUK__DUMPLM_UNSIGNED(UINT8); - DUK__DUMPLM_SIGNED(INT_FAST8); - DUK__DUMPLM_UNSIGNED(UINT_FAST8); - DUK__DUMPLM_SIGNED(INT_LEAST8); - DUK__DUMPLM_UNSIGNED(UINT_LEAST8); - DUK__DUMPLM_SIGNED(INT16); - DUK__DUMPLM_UNSIGNED(UINT16); - DUK__DUMPLM_SIGNED(INT_FAST16); - DUK__DUMPLM_UNSIGNED(UINT_FAST16); - DUK__DUMPLM_SIGNED(INT_LEAST16); - DUK__DUMPLM_UNSIGNED(UINT_LEAST16); - DUK__DUMPLM_SIGNED(INT32); - DUK__DUMPLM_UNSIGNED(UINT32); - DUK__DUMPLM_SIGNED(INT_FAST32); - DUK__DUMPLM_UNSIGNED(UINT_FAST32); - DUK__DUMPLM_SIGNED(INT_LEAST32); - DUK__DUMPLM_UNSIGNED(UINT_LEAST32); -#if defined(DUK_USE_64BIT_OPS) - DUK__DUMPLM_SIGNED(INT64); - DUK__DUMPLM_UNSIGNED(UINT64); - DUK__DUMPLM_SIGNED(INT_FAST64); - DUK__DUMPLM_UNSIGNED(UINT_FAST64); - DUK__DUMPLM_SIGNED(INT_LEAST64); - DUK__DUMPLM_UNSIGNED(UINT_LEAST64); -#endif - DUK__DUMPLM_SIGNED(INTPTR); - DUK__DUMPLM_UNSIGNED(UINTPTR); - DUK__DUMPLM_SIGNED(INTMAX); - DUK__DUMPLM_UNSIGNED(UINTMAX); - - /* derived types */ - DUK__DUMPLM_SIGNED(INT); - DUK__DUMPLM_UNSIGNED(UINT); - DUK__DUMPLM_SIGNED(INT_FAST); - DUK__DUMPLM_UNSIGNED(UINT_FAST); - DUK__DUMPLM_SIGNED(SMALL_INT); - DUK__DUMPLM_UNSIGNED(SMALL_UINT); - DUK__DUMPLM_SIGNED(SMALL_INT_FAST); - DUK__DUMPLM_UNSIGNED(SMALL_UINT_FAST); -} -#undef DUK__DUMPSZ -#undef DUK__DUMPLM_SIGNED_RAW -#undef DUK__DUMPLM_UNSIGNED_RAW -#undef DUK__DUMPLM_SIGNED -#undef DUK__DUMPLM_UNSIGNED - -DUK_LOCAL void duk__dump_misc_options(void) { - DUK_D(DUK_DPRINT("DUK_VERSION: %ld", (long) DUK_VERSION)); - DUK_D(DUK_DPRINT("DUK_GIT_DESCRIBE: %s", DUK_GIT_DESCRIBE)); - DUK_D(DUK_DPRINT("OS string: %s", DUK_USE_OS_STRING)); - DUK_D(DUK_DPRINT("architecture string: %s", DUK_USE_ARCH_STRING)); - DUK_D(DUK_DPRINT("compiler string: %s", DUK_USE_COMPILER_STRING)); -#if defined(DUK_USE_PACKED_TVAL) - DUK_D(DUK_DPRINT("DUK_USE_PACKED_TVAL: yes")); -#else - DUK_D(DUK_DPRINT("DUK_USE_PACKED_TVAL: no")); -#endif -#if defined(DUK_USE_VARIADIC_MACROS) - DUK_D(DUK_DPRINT("DUK_USE_VARIADIC_MACROS: yes")); -#else - DUK_D(DUK_DPRINT("DUK_USE_VARIADIC_MACROS: no")); -#endif -#if defined(DUK_USE_INTEGER_LE) - DUK_D(DUK_DPRINT("integer endianness: little")); -#elif defined(DUK_USE_INTEGER_ME) - DUK_D(DUK_DPRINT("integer endianness: mixed")); -#elif defined(DUK_USE_INTEGER_BE) - DUK_D(DUK_DPRINT("integer endianness: big")); -#else - DUK_D(DUK_DPRINT("integer endianness: ???")); -#endif -#if defined(DUK_USE_DOUBLE_LE) - DUK_D(DUK_DPRINT("IEEE double endianness: little")); -#elif defined(DUK_USE_DOUBLE_ME) - DUK_D(DUK_DPRINT("IEEE double endianness: mixed")); -#elif defined(DUK_USE_DOUBLE_BE) - DUK_D(DUK_DPRINT("IEEE double endianness: big")); -#else - DUK_D(DUK_DPRINT("IEEE double endianness: ???")); -#endif -} -#endif /* DUK_USE_DEBUG */ - -DUK_INTERNAL -duk_heap *duk_heap_alloc(duk_alloc_function alloc_func, - duk_realloc_function realloc_func, - duk_free_function free_func, - void *heap_udata, - duk_fatal_function fatal_func) { - duk_heap *res = NULL; - - /* Silence a few global unused warnings here. */ - DUK_UNREF(duk_str_unsupported); - - DUK_D(DUK_DPRINT("allocate heap")); - - /* - * Debug dump type sizes - */ - -#if defined(DUK_USE_DEBUG) - duk__dump_misc_options(); - duk__dump_type_sizes(); - duk__dump_type_limits(); -#endif - - /* - * If selftests enabled, run them as early as possible - */ -#if defined(DUK_USE_SELF_TESTS) - DUK_D(DUK_DPRINT("running self tests")); - duk_selftest_run_tests(); - DUK_D(DUK_DPRINT("self tests passed")); -#endif - - /* - * Computed values (e.g. INFINITY) - */ - -#if defined(DUK_USE_COMPUTED_NAN) - do { - /* Workaround for some exotic platforms where NAN is missing - * and the expression (0.0 / 0.0) does NOT result in a NaN. - * Such platforms use the global 'duk_computed_nan' which must - * be initialized at runtime. Use 'volatile' to ensure that - * the compiler will actually do the computation and not try - * to do constant folding which might result in the original - * problem. - */ - volatile double dbl1 = 0.0; - volatile double dbl2 = 0.0; - duk_computed_nan = dbl1 / dbl2; - } while (0); -#endif - -#if defined(DUK_USE_COMPUTED_INFINITY) - do { - /* Similar workaround for INFINITY. */ - volatile double dbl1 = 1.0; - volatile double dbl2 = 0.0; - duk_computed_infinity = dbl1 / dbl2; - } while (0); -#endif - - /* - * Allocate heap struct - * - * Use a raw call, all macros expect the heap to be initialized - */ - - res = (duk_heap *) alloc_func(heap_udata, sizeof(duk_heap)); - if (!res) { - goto error; - } - - /* - * Zero the struct, and start initializing roughly in order - */ - - DUK_MEMZERO(res, sizeof(*res)); - - /* explicit NULL inits */ -#if defined(DUK_USE_EXPLICIT_NULL_INIT) - res->heap_udata = NULL; - res->heap_allocated = NULL; -#if defined(DUK_USE_REFERENCE_COUNTING) - res->refzero_list = NULL; - res->refzero_list_tail = NULL; -#endif -#if defined(DUK_USE_MARK_AND_SWEEP) - res->finalize_list = NULL; -#endif - res->heap_thread = NULL; - res->curr_thread = NULL; - res->heap_object = NULL; -#if defined(DUK_USE_STRTAB_CHAIN) - /* nothing to NULL */ -#elif defined(DUK_USE_STRTAB_PROBE) -#if defined(DUK_USE_HEAPPTR16) - res->strtable16 = (duk_uint16_t *) NULL; -#else - res->strtable = (duk_hstring **) NULL; -#endif -#endif -#if defined(DUK_USE_ROM_STRINGS) - /* no res->strs[] */ -#else /* DUK_USE_ROM_STRINGS */ -#if defined(DUK_USE_HEAPPTR16) - /* res->strs16[] is zeroed and zero decodes to NULL, so no NULL inits. */ -#else - { - duk_small_uint_t i; - for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) { - res->strs[i] = NULL; - } - } -#endif -#endif /* DUK_USE_ROM_STRINGS */ -#if defined(DUK_USE_DEBUGGER_SUPPORT) - res->dbg_read_cb = NULL; - res->dbg_write_cb = NULL; - res->dbg_peek_cb = NULL; - res->dbg_read_flush_cb = NULL; - res->dbg_write_flush_cb = NULL; - res->dbg_request_cb = NULL; - res->dbg_udata = NULL; - res->dbg_step_thread = NULL; -#endif -#endif /* DUK_USE_EXPLICIT_NULL_INIT */ - - res->alloc_func = alloc_func; - res->realloc_func = realloc_func; - res->free_func = free_func; - res->heap_udata = heap_udata; - res->fatal_func = fatal_func; - -#if defined(DUK_USE_HEAPPTR16) - /* XXX: zero assumption */ - res->heapptr_null16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) NULL); - res->heapptr_deleted16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) DUK_STRTAB_DELETED_MARKER(res)); -#endif - - /* res->mark_and_sweep_trigger_counter == 0 -> now causes immediate GC; which is OK */ - - res->call_recursion_depth = 0; - res->call_recursion_limit = DUK_USE_NATIVE_CALL_RECLIMIT; - - /* XXX: use the pointer as a seed for now: mix in time at least */ - - /* The casts through duk_intr_pt is to avoid the following GCC warning: - * - * warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] - * - * This still generates a /Wp64 warning on VS2010 when compiling for x86. - */ -#if defined(DUK_USE_ROM_STRINGS) - /* XXX: make a common DUK_USE_ option, and allow custom fixed seed? */ - DUK_D(DUK_DPRINT("using rom strings, force heap hash_seed to fixed value 0x%08lx", (long) DUK__FIXED_HASH_SEED)); - res->hash_seed = (duk_uint32_t) DUK__FIXED_HASH_SEED; -#else /* DUK_USE_ROM_STRINGS */ - res->hash_seed = (duk_uint32_t) (duk_intptr_t) res; - res->rnd_state = (duk_uint32_t) (duk_intptr_t) res; -#if !defined(DUK_USE_STRHASH_DENSE) - res->hash_seed ^= 5381; /* Bernstein hash init value is normally 5381; XOR it in in case pointer low bits are 0 */ -#endif -#endif /* DUK_USE_ROM_STRINGS */ - -#if defined(DUK_USE_EXPLICIT_NULL_INIT) - res->lj.jmpbuf_ptr = NULL; -#endif - DUK_ASSERT(res->lj.type == DUK_LJ_TYPE_UNKNOWN); /* zero */ - - DUK_TVAL_SET_UNDEFINED(&res->lj.value1); - DUK_TVAL_SET_UNDEFINED(&res->lj.value2); - -#if (DUK_STRTAB_INITIAL_SIZE < DUK_UTIL_MIN_HASH_PRIME) -#error initial heap stringtable size is defined incorrectly -#endif - - /* - * Init stringtable: fixed variant - */ - -#if defined(DUK_USE_STRTAB_CHAIN) - DUK_MEMZERO(res->strtable, sizeof(duk_strtab_entry) * DUK_STRTAB_CHAIN_SIZE); -#if defined(DUK_USE_EXPLICIT_NULL_INIT) - { - duk_small_uint_t i; - for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) { -#if defined(DUK_USE_HEAPPTR16) - res->strtable[i].u.str16 = res->heapptr_null16; -#else - res->strtable[i].u.str = NULL; -#endif - } - } -#endif /* DUK_USE_EXPLICIT_NULL_INIT */ -#endif /* DUK_USE_STRTAB_CHAIN */ - - /* - * Init stringtable: probe variant - */ - -#if defined(DUK_USE_STRTAB_PROBE) -#if defined(DUK_USE_HEAPPTR16) - res->strtable16 = (duk_uint16_t *) alloc_func(heap_udata, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE); - if (!res->strtable16) { - goto error; - } -#else /* DUK_USE_HEAPPTR16 */ - res->strtable = (duk_hstring **) alloc_func(heap_udata, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE); - if (!res->strtable) { - goto error; - } -#endif /* DUK_USE_HEAPPTR16 */ - res->st_size = DUK_STRTAB_INITIAL_SIZE; -#if defined(DUK_USE_EXPLICIT_NULL_INIT) - { - duk_small_uint_t i; - DUK_ASSERT(res->st_size == DUK_STRTAB_INITIAL_SIZE); - for (i = 0; i < DUK_STRTAB_INITIAL_SIZE; i++) { -#if defined(DUK_USE_HEAPPTR16) - res->strtable16[i] = res->heapptr_null16; -#else - res->strtable[i] = NULL; -#endif - } - } -#else /* DUK_USE_EXPLICIT_NULL_INIT */ -#if defined(DUK_USE_HEAPPTR16) - DUK_MEMZERO(res->strtable16, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE); -#else - DUK_MEMZERO(res->strtable, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE); -#endif -#endif /* DUK_USE_EXPLICIT_NULL_INIT */ -#endif /* DUK_USE_STRTAB_PROBE */ - - /* - * Init stringcache - */ - -#if defined(DUK_USE_EXPLICIT_NULL_INIT) - { - duk_small_uint_t i; - for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) { - res->strcache[i].h = NULL; - } - } -#endif - - /* XXX: error handling is incomplete. It would be cleanest if - * there was a setjmp catchpoint, so that all init code could - * freely throw errors. If that were the case, the return code - * passing here could be removed. - */ - - /* - * Init built-in strings - */ - - DUK_DD(DUK_DDPRINT("HEAP: INIT STRINGS")); - if (!duk__init_heap_strings(res)) { - goto error; - } - - /* - * Init the heap thread - */ - - DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP THREAD")); - if (!duk__init_heap_thread(res)) { - goto error; - } - - /* - * Init the heap object - */ - - DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP OBJECT")); - DUK_ASSERT(res->heap_thread != NULL); - res->heap_object = duk_hobject_alloc(res, DUK_HOBJECT_FLAG_EXTENSIBLE | - DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT)); - if (!res->heap_object) { - goto error; - } - DUK_HOBJECT_INCREF(res->heap_thread, res->heap_object); - - /* - * All done - */ - - DUK_D(DUK_DPRINT("allocated heap: %p", (void *) res)); - return res; - - error: - DUK_D(DUK_DPRINT("heap allocation failed")); - - if (res) { - /* assumes that allocated pointers and alloc funcs are valid - * if res exists - */ - DUK_ASSERT(res->alloc_func != NULL); - DUK_ASSERT(res->realloc_func != NULL); - DUK_ASSERT(res->free_func != NULL); - duk_heap_free(res); - } - return NULL; -} - -#undef DUK__BITPACK_LETTER_LIMIT -#undef DUK__BITPACK_UNDERSCORE -#undef DUK__BITPACK_FF -#undef DUK__BITPACK_SWITCH1 -#undef DUK__BITPACK_SWITCH -#undef DUK__BITPACK_SEVENBIT -#undef DUK__FIXED_HASH_SEED
