nifi-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ald...@apache.org
Subject [18/51] [abbrv] [partial] nifi-minifi-cpp git commit: MINIFI-293 Remove thirdparty dependencies no longer utilized inclusive of libxml2 and all of civetweb thirdparty
Date Thu, 04 May 2017 19:10:26 GMT
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/b8103f03/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_alloc.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_alloc.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_alloc.c
deleted file mode 100644
index 425ad33..0000000
--- a/thirdparty/civetweb-1.9.1/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/b8103f03/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_ops.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_ops.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer_ops.c
deleted file mode 100644
index 4cdf598..0000000
--- a/thirdparty/civetweb-1.9.1/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/b8103f03/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject.h b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject.h
deleted file mode 100644
index dd93902..0000000
--- a/thirdparty/civetweb-1.9.1/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/b8103f03/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject_misc.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject_misc.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbufferobject_misc.c
deleted file mode 100644
index f692918..0000000
--- a/thirdparty/civetweb-1.9.1/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/b8103f03/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hcompiledfunction.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hcompiledfunction.h b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hcompiledfunction.h
deleted file mode 100644
index 04b9ea1..0000000
--- a/thirdparty/civetweb-1.9.1/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/b8103f03/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_heap.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_heap.h b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_heap.h
deleted file mode 100644
index 5f96b1a..0000000
--- a/thirdparty/civetweb-1.9.1/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/b8103f03/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_heap_alloc.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_heap_alloc.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_heap_alloc.c
deleted file mode 100644
index b89fe48..0000000
--- a/thirdparty/civetweb-1.9.1/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


Mime
View raw message