[16/51] [partial] nifi-minifi-cpp git commit: MINIFICPP-351: Remove Civetweb third party directory

[ph...@apache.org]

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_stringcache.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap_stringcache.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap_stringcache.c
deleted file mode 100644
index ace607e..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap_stringcache.c
+++ /dev/null
@@ -1,298 +0,0 @@
-/*
- *  String cache.
- *
- *  Provides a cache to optimize indexed string lookups.  The cache keeps
- *  track of (byte offset, char offset) states for a fixed number of strings.
- *  Otherwise we'd need to scan from either end of the string, as we store
- *  strings in (extended) UTF-8.
- */
-
-#include "duk_internal.h"
-
-/*
- *  Delete references to given hstring from the heap string cache.
- *
- *  String cache references are 'weak': they are not counted towards
- *  reference counts, nor serve as roots for mark-and-sweep.  When an
- *  object is about to be freed, such references need to be removed.
- */
-
-DUK_INTERNAL void duk_heap_strcache_string_remove(duk_heap *heap, duk_hstring *h) {
-	duk_small_int_t i;
-	for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
-		duk_strcache *c = heap->strcache + i;
-		if (c->h == h) {
-			DUK_DD(DUK_DDPRINT("deleting weak strcache reference to hstring %p from heap %p",
-			                   (void *) h, (void *) heap));
-			c->h = NULL;
-
-			/* XXX: the string shouldn't appear twice, but we now loop to the
-			 * end anyway; if fixed, add a looping assertion to ensure there
-			 * is no duplicate.
-			 */
-		}
-	}
-}
-
-/*
- *  String scanning helpers
- *
- *  All bytes other than UTF-8 continuation bytes ([0x80,0xbf]) are
- *  considered to contribute a character.  This must match how string
- *  character length is computed.
- */
-
-DUK_LOCAL const duk_uint8_t *duk__scan_forwards(const duk_uint8_t *p, const duk_uint8_t *q, duk_uint_fast32_t n) {
-	while (n > 0) {
-		for (;;) {
-			p++;
-			if (p >= q) {
-				return NULL;
-			}
-			if ((*p & 0xc0) != 0x80) {
-				break;
-			}
-		}
-		n--;
-	}
-	return p;
-}
-
-DUK_LOCAL const duk_uint8_t *duk__scan_backwards(const duk_uint8_t *p, const duk_uint8_t *q, duk_uint_fast32_t n) {
-	while (n > 0) {
-		for (;;) {
-			p--;
-			if (p < q) {
-				return NULL;
-			}
-			if ((*p & 0xc0) != 0x80) {
-				break;
-			}
-		}
-		n--;
-	}
-	return p;
-}
-
-/*
- *  Convert char offset to byte offset
- *
- *  Avoid using the string cache if possible: for ASCII strings byte and
- *  char offsets are equal and for short strings direct scanning may be
- *  better than using the string cache (which may evict a more important
- *  entry).
- *
- *  Typing now assumes 32-bit string byte/char offsets (duk_uint_fast32_t).
- *  Better typing might be to use duk_size_t.
- */
-
-DUK_INTERNAL duk_uint_fast32_t duk_heap_strcache_offset_char2byte(duk_hthread *thr, duk_hstring *h, duk_uint_fast32_t char_offset) {
-	duk_heap *heap;
-	duk_strcache *sce;
-	duk_uint_fast32_t byte_offset;
-	duk_small_int_t i;
-	duk_bool_t use_cache;
-	duk_uint_fast32_t dist_start, dist_end, dist_sce;
-	const duk_uint8_t *p_start;
-	const duk_uint8_t *p_end;
-	const duk_uint8_t *p_found;
-
-	if (char_offset > DUK_HSTRING_GET_CHARLEN(h)) {
-		goto error;
-	}
-
-	/*
-	 *  For ASCII strings, the answer is simple.
-	 */
-
-	if (DUK_HSTRING_IS_ASCII(h)) {
-		/* clen == blen -> pure ascii */
-		return char_offset;
-	}
-
-	/*
-	 *  For non-ASCII strings, we need to scan forwards or backwards
-	 *  from some starting point.  The starting point may be the start
-	 *  or end of the string, or some cached midpoint in the string
-	 *  cache.
-	 *
-	 *  For "short" strings we simply scan without checking or updating
-	 *  the cache.  For longer strings we check and update the cache as
-	 *  necessary, inserting a new cache entry if none exists.
-	 */
-
-	DUK_DDD(DUK_DDDPRINT("non-ascii string %p, char_offset=%ld, clen=%ld, blen=%ld",
-	                     (void *) h, (long) char_offset,
-	                     (long) DUK_HSTRING_GET_CHARLEN(h),
-	                     (long) DUK_HSTRING_GET_BYTELEN(h)));
-
-	heap = thr->heap;
-	sce = NULL;
-	use_cache = (DUK_HSTRING_GET_CHARLEN(h) > DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT);
-
-	if (use_cache) {
-#ifdef DUK_USE_DDDPRINT
-		DUK_DDD(DUK_DDDPRINT("stringcache before char2byte (using cache):"));
-		for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
-			duk_strcache *c = heap->strcache + i;
-			DUK_DDD(DUK_DDDPRINT("  [%ld] -> h=%p, cidx=%ld, bidx=%ld",
-			                     (long) i, (void *) c->h, (long) c->cidx, (long) c->bidx));
-		}
-#endif
-
-		for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
-			duk_strcache *c = heap->strcache + i;
-
-			if (c->h == h) {
-				sce = c;
-				break;
-			}
-		}
-	}
-
-	/*
-	 *  Scan from shortest distance:
-	 *    - start of string
-	 *    - end of string
-	 *    - cache entry (if exists)
-	 */
-
-	DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h) >= char_offset);
-	dist_start = char_offset;
-	dist_end = DUK_HSTRING_GET_CHARLEN(h) - char_offset;
-	dist_sce = 0; DUK_UNREF(dist_sce);  /* initialize for debug prints, needed if sce==NULL */
-
-	p_start = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h);
-	p_end = (const duk_uint8_t *) (p_start + DUK_HSTRING_GET_BYTELEN(h));
-	p_found = NULL;
-
-	if (sce) {
-		if (char_offset >= sce->cidx) {
-			dist_sce = char_offset - sce->cidx;
-			if ((dist_sce <= dist_start) && (dist_sce <= dist_end)) {
-				DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
-				                     "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
-				                     "scan forwards from sce",
-				                     (long) use_cache, (void *) (sce ? sce->h : NULL),
-				                     (sce ? (long) sce->cidx : (long) -1),
-				                     (sce ? (long) sce->bidx : (long) -1),
-				                     (long) dist_start, (long) dist_end, (long) dist_sce));
-
-				p_found = duk__scan_forwards(p_start + sce->bidx,
-				                             p_end,
-				                             dist_sce);
-				goto scan_done;
-			}
-		} else {
-			dist_sce = sce->cidx - char_offset;
-			if ((dist_sce <= dist_start) && (dist_sce <= dist_end)) {
-				DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
-				                     "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
-				                     "scan backwards from sce",
-				                     (long) use_cache, (void *) (sce ? sce->h : NULL),
-				                     (sce ? (long) sce->cidx : (long) -1),
-				                     (sce ? (long) sce->bidx : (long) -1),
-				                     (long) dist_start, (long) dist_end, (long) dist_sce));
-
-				p_found = duk__scan_backwards(p_start + sce->bidx,
-				                              p_start,
-				                              dist_sce);
-				goto scan_done;
-			}
-		}
-	}
-
-	/* no sce, or sce scan not best */
-
-	if (dist_start <= dist_end) {
-		DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
-		                     "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
-		                     "scan forwards from string start",
-		                     (long) use_cache, (void *) (sce ? sce->h : NULL),
-		                     (sce ? (long) sce->cidx : (long) -1),
-		                     (sce ? (long) sce->bidx : (long) -1),
-		                     (long) dist_start, (long) dist_end, (long) dist_sce));
-
-		p_found = duk__scan_forwards(p_start,
-		                             p_end,
-		                             dist_start);
-	} else {
-		DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
-		                     "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
-		                     "scan backwards from string end",
-		                     (long) use_cache, (void *) (sce ? sce->h : NULL),
-		                     (sce ? (long) sce->cidx : (long) -1),
-		                     (sce ? (long) sce->bidx : (long) -1),
-		                     (long) dist_start, (long) dist_end, (long) dist_sce));
-
-		p_found = duk__scan_backwards(p_end,
-		                              p_start,
-		                              dist_end);
-	}
-
- scan_done:
-
-	if (!p_found) {
-		/* Scan error: this shouldn't normally happen; it could happen if
-		 * string is not valid UTF-8 data, and clen/blen are not consistent
-		 * with the scanning algorithm.
-		 */
-		goto error;
-	}
-
-	DUK_ASSERT(p_found >= p_start);
-	DUK_ASSERT(p_found <= p_end);  /* may be equal */
-	byte_offset = (duk_uint32_t) (p_found - p_start);
-
-	DUK_DDD(DUK_DDDPRINT("-> string %p, cidx %ld -> bidx %ld",
-	                     (void *) h, (long) char_offset, (long) byte_offset));
-
-	/*
-	 *  Update cache entry (allocating if necessary), and move the
-	 *  cache entry to the first place (in an "LRU" policy).
-	 */
-
-	if (use_cache) {
-		/* update entry, allocating if necessary */
-		if (!sce) {
-			sce = heap->strcache + DUK_HEAP_STRCACHE_SIZE - 1;  /* take last entry */
-			sce->h = h;
-		}
-		DUK_ASSERT(sce != NULL);
-		sce->bidx = (duk_uint32_t) (p_found - p_start);
-		sce->cidx = (duk_uint32_t) char_offset;
-
-		/* LRU: move our entry to first */
-		if (sce > &heap->strcache[0]) {
-			/*
-			 *   A                  C
-			 *   B                  A
-			 *   C <- sce    ==>    B
-			 *   D                  D
-			 */
-			duk_strcache tmp;
-
-			tmp = *sce;
-			DUK_MEMMOVE((void *) (&heap->strcache[1]),
-			            (const void *) (&heap->strcache[0]),
-			            (size_t) (((char *) sce) - ((char *) &heap->strcache[0])));
-			heap->strcache[0] = tmp;
-
-			/* 'sce' points to the wrong entry here, but is no longer used */
-		}
-#ifdef DUK_USE_DDDPRINT
-		DUK_DDD(DUK_DDDPRINT("stringcache after char2byte (using cache):"));
-		for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
-			duk_strcache *c = heap->strcache + i;
-			DUK_DDD(DUK_DDDPRINT("  [%ld] -> h=%p, cidx=%ld, bidx=%ld",
-			                     (long) i, (void *) c->h, (long) c->cidx, (long) c->bidx));
-		}
-#endif
-	}
-
-	return byte_offset;
-
- error:
-	DUK_ERROR_INTERNAL_DEFMSG(thr);
-	return 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_heap_stringtable.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap_stringtable.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap_stringtable.c
deleted file mode 100644
index ad0a4fc..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heap_stringtable.c
+++ /dev/null
@@ -1,1181 +0,0 @@
-/*
- *  Heap stringtable handling, string interning.
- */
-
-#include "duk_internal.h"
-
-#if defined(DUK_USE_STRTAB_PROBE)
-#define DUK__HASH_INITIAL(hash,h_size)        DUK_STRTAB_HASH_INITIAL((hash),(h_size))
-#define DUK__HASH_PROBE_STEP(hash)            DUK_STRTAB_HASH_PROBE_STEP((hash))
-#define DUK__DELETED_MARKER(heap)             DUK_STRTAB_DELETED_MARKER((heap))
-#endif
-
-#if defined(DUK_USE_MARK_AND_SWEEP)
-#define DUK__PREVENT_MS_SIDE_EFFECTS(heap) do { \
-		(heap)->mark_and_sweep_base_flags |= \
-		        DUK_MS_FLAG_NO_STRINGTABLE_RESIZE |  /* avoid recursive string table call */ \
-		        DUK_MS_FLAG_NO_FINALIZERS |          /* avoid pressure to add/remove strings, invalidation of call data argument, etc. */ \
-		        DUK_MS_FLAG_NO_OBJECT_COMPACTION;    /* avoid array abandoning which interns strings */ \
-	} while (0)
-#endif
-
-/*
- *  Create a hstring and insert into the heap.  The created object
- *  is directly garbage collectable with reference count zero.
- *
- *  The caller must place the interned string into the stringtable
- *  immediately (without chance of a longjmp); otherwise the string
- *  is lost.
- */
-
-DUK_LOCAL
-duk_hstring *duk__alloc_init_hstring(duk_heap *heap,
-                                     const duk_uint8_t *str,
-                                     duk_uint32_t blen,
-                                     duk_uint32_t strhash,
-                                     const duk_uint8_t *extdata) {
-	duk_hstring *res = NULL;
-	duk_uint8_t *data;
-	duk_size_t alloc_size;
-	duk_uarridx_t dummy;
-	duk_uint32_t clen;
-
-#if defined(DUK_USE_STRLEN16)
-	/* If blen <= 0xffffUL, clen is also guaranteed to be <= 0xffffUL. */
-	if (blen > 0xffffUL) {
-		DUK_D(DUK_DPRINT("16-bit string blen/clen active and blen over 16 bits, reject intern"));
-		return NULL;
-	}
-#endif
-
-	if (extdata) {
-		alloc_size = (duk_size_t) sizeof(duk_hstring_external);
-		res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
-		if (!res) {
-			goto alloc_error;
-		}
-		DUK_MEMZERO(res, sizeof(duk_hstring_external));
-#if defined(DUK_USE_EXPLICIT_NULL_INIT)
-		DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr);
-#endif
-		DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, DUK_HSTRING_FLAG_EXTDATA);
-
-		((duk_hstring_external *) res)->extdata = extdata;
-	} else {
-		/* NUL terminate for convenient C access */
-		alloc_size = (duk_size_t) (sizeof(duk_hstring) + blen + 1);
-		res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
-		if (!res) {
-			goto alloc_error;
-		}
-		DUK_MEMZERO(res, sizeof(duk_hstring));
-#if defined(DUK_USE_EXPLICIT_NULL_INIT)
-		DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr);
-#endif
-		DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, 0);
-
-		data = (duk_uint8_t *) (res + 1);
-		DUK_MEMCPY(data, str, blen);
-		data[blen] = (duk_uint8_t) 0;
-	}
-
-	DUK_ASSERT(!DUK_HSTRING_HAS_ARRIDX(res));
-	if (duk_js_to_arrayindex_raw_string(str, blen, &dummy)) {
-		DUK_HSTRING_SET_ARRIDX(res);
-	}
-
-	/* All strings beginning with 0xff are treated as "internal",
-	 * even strings interned by the user.  This allows user code to
-	 * create internal properties too, and makes behavior consistent
-	 * in case user code happens to use a string also used by Duktape
-	 * (such as string has already been interned and has the 'internal'
-	 * flag set).
-	 */
-	DUK_ASSERT(!DUK_HSTRING_HAS_INTERNAL(res));
-	if (blen > 0 && str[0] == (duk_uint8_t) 0xff) {
-		DUK_HSTRING_SET_INTERNAL(res);
-	}
-
-	DUK_HSTRING_SET_HASH(res, strhash);
-	DUK_HSTRING_SET_BYTELEN(res, blen);
-
-	clen = (duk_uint32_t) duk_unicode_unvalidated_utf8_length(str, (duk_size_t) blen);
-	DUK_ASSERT(clen <= blen);
-#if defined(DUK_USE_HSTRING_CLEN)
-	DUK_HSTRING_SET_CHARLEN(res, clen);
-#endif
-
-	/* Using an explicit 'ASCII' flag has larger footprint (one call site
-	 * only) but is quite useful for the case when there's no explicit
-	 * 'clen' in duk_hstring.
-	 */
-	DUK_ASSERT(!DUK_HSTRING_HAS_ASCII(res));
-	if (clen == blen) {
-		DUK_HSTRING_SET_ASCII(res);
-	}
-
-	DUK_DDD(DUK_DDDPRINT("interned string, hash=0x%08lx, blen=%ld, clen=%ld, has_arridx=%ld, has_extdata=%ld",
-	                     (unsigned long) DUK_HSTRING_GET_HASH(res),
-	                     (long) DUK_HSTRING_GET_BYTELEN(res),
-	                     (long) DUK_HSTRING_GET_CHARLEN(res),
-	                     (long) (DUK_HSTRING_HAS_ARRIDX(res) ? 1 : 0),
-	                     (long) (DUK_HSTRING_HAS_EXTDATA(res) ? 1 : 0)));
-
-	return res;
-
- alloc_error:
-	DUK_FREE(heap, res);
-	return NULL;
-}
-
-/*
- *  String table algorithm: fixed size string table with array chaining
- *
- *  The top level string table has a fixed size, with each slot holding
- *  either NULL, string pointer, or pointer to a separately allocated
- *  string pointer list.
- *
- *  This is good for low memory environments using a pool allocator: the
- *  top level allocation has a fixed size and the pointer lists have quite
- *  small allocation size, which further matches the typical pool sizes
- *  needed by objects, strings, property tables, etc.
- */
-
-#if defined(DUK_USE_STRTAB_CHAIN)
-
-#if defined(DUK_USE_HEAPPTR16)
-DUK_LOCAL duk_bool_t duk__insert_hstring_chain(duk_heap *heap, duk_hstring *h) {
-	duk_small_uint_t slotidx;
-	duk_strtab_entry *e;
-	duk_uint16_t *lst;
-	duk_uint16_t *new_lst;
-	duk_size_t i, n;
-	duk_uint16_t null16 = heap->heapptr_null16;
-	duk_uint16_t h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-
-	DUK_ASSERT(heap != NULL);
-	DUK_ASSERT(h != NULL);
-
-	slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE;
-	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-
-	e = heap->strtable + slotidx;
-	if (e->listlen == 0) {
-		if (e->u.str16 == null16) {
-			e->u.str16 = h16;
-		} else {
-			/* Now two entries in the same slot, alloc list */
-			lst = (duk_uint16_t *) DUK_ALLOC(heap, sizeof(duk_uint16_t) * 2);
-			if (lst == NULL) {
-				return 1;  /* fail */
-			}
-			lst[0] = e->u.str16;
-			lst[1] = h16;
-			e->u.strlist16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) lst);
-			e->listlen = 2;
-		}
-	} else {
-		DUK_ASSERT(e->u.strlist16 != null16);
-		lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-		DUK_ASSERT(lst != NULL);
-		for (i = 0, n = e->listlen; i < n; i++) {
-			if (lst[i] == null16) {
-				lst[i] = h16;
-				return 0;
-			}
-		}
-
-		if (e->listlen + 1 == 0) {
-			/* Overflow, relevant mainly when listlen is 16 bits. */
-			return 1;  /* fail */
-		}
-
-		new_lst = (duk_uint16_t *) DUK_REALLOC(heap, lst, sizeof(duk_uint16_t) * (e->listlen + 1));
-		if (new_lst == NULL) {
-			return 1;  /* fail */
-		}
-		new_lst[e->listlen++] = h16;
-		e->u.strlist16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) new_lst);
-	}
-	return 0;
-}
-#else  /* DUK_USE_HEAPPTR16 */
-DUK_LOCAL duk_bool_t duk__insert_hstring_chain(duk_heap *heap, duk_hstring *h) {
-	duk_small_uint_t slotidx;
-	duk_strtab_entry *e;
-	duk_hstring **lst;
-	duk_hstring **new_lst;
-	duk_size_t i, n;
-
-	DUK_ASSERT(heap != NULL);
-	DUK_ASSERT(h != NULL);
-
-	slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE;
-	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-
-	e = heap->strtable + slotidx;
-	if (e->listlen == 0) {
-		if (e->u.str == NULL) {
-			e->u.str = h;
-		} else {
-			/* Now two entries in the same slot, alloc list */
-			lst = (duk_hstring **) DUK_ALLOC(heap, sizeof(duk_hstring *) * 2);
-			if (lst == NULL) {
-				return 1;  /* fail */
-			}
-			lst[0] = e->u.str;
-			lst[1] = h;
-			e->u.strlist = lst;
-			e->listlen = 2;
-		}
-	} else {
-		DUK_ASSERT(e->u.strlist != NULL);
-		lst = e->u.strlist;
-		for (i = 0, n = e->listlen; i < n; i++) {
-			if (lst[i] == NULL) {
-				lst[i] = h;
-				return 0;
-			}
-		}
-
-		if (e->listlen + 1 == 0) {
-			/* Overflow, relevant mainly when listlen is 16 bits. */
-			return 1;  /* fail */
-		}
-
-		new_lst = (duk_hstring **) DUK_REALLOC(heap, e->u.strlist, sizeof(duk_hstring *) * (e->listlen + 1));
-		if (new_lst == NULL) {
-			return 1;  /* fail */
-		}
-		new_lst[e->listlen++] = h;
-		e->u.strlist = new_lst;
-	}
-	return 0;
-}
-#endif  /* DUK_USE_HEAPPTR16 */
-
-#if defined(DUK_USE_HEAPPTR16)
-DUK_LOCAL duk_hstring *duk__find_matching_string_chain(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
-	duk_small_uint_t slotidx;
-	duk_strtab_entry *e;
-	duk_uint16_t *lst;
-	duk_size_t i, n;
-	duk_uint16_t null16 = heap->heapptr_null16;
-
-	DUK_ASSERT(heap != NULL);
-
-	slotidx = strhash % DUK_STRTAB_CHAIN_SIZE;
-	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-
-	e = heap->strtable + slotidx;
-	if (e->listlen == 0) {
-		if (e->u.str16 != null16) {
-			duk_hstring *h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.str16);
-			DUK_ASSERT(h != NULL);
-			if (DUK_HSTRING_GET_BYTELEN(h) == blen &&
-			    DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(h), (size_t) blen) == 0) {
-				return h;
-			}
-		}
-	} else {
-		DUK_ASSERT(e->u.strlist16 != null16);
-		lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-		DUK_ASSERT(lst != NULL);
-		for (i = 0, n = e->listlen; i < n; i++) {
-			if (lst[i] != null16) {
-				duk_hstring *h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, lst[i]);
-				DUK_ASSERT(h != NULL);
-				if (DUK_HSTRING_GET_BYTELEN(h) == blen &&
-				    DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(h), (size_t) blen) == 0) {
-					return h;
-				}
-			}
-		}
-	}
-
-	return NULL;
-}
-#else  /* DUK_USE_HEAPPTR16 */
-DUK_LOCAL duk_hstring *duk__find_matching_string_chain(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
-	duk_small_uint_t slotidx;
-	duk_strtab_entry *e;
-	duk_hstring **lst;
-	duk_size_t i, n;
-
-	DUK_ASSERT(heap != NULL);
-
-	slotidx = strhash % DUK_STRTAB_CHAIN_SIZE;
-	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-
-	e = heap->strtable + slotidx;
-	if (e->listlen == 0) {
-		if (e->u.str != NULL &&
-	           DUK_HSTRING_GET_BYTELEN(e->u.str) == blen &&
-	           DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(e->u.str), (size_t) blen) == 0) {
-			return e->u.str;
-		}
-	} else {
-		DUK_ASSERT(e->u.strlist != NULL);
-		lst = e->u.strlist;
-		for (i = 0, n = e->listlen; i < n; i++) {
-			if (lst[i] != NULL &&
-		           DUK_HSTRING_GET_BYTELEN(lst[i]) == blen &&
-		           DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(lst[i]), (size_t) blen) == 0) {
-				return lst[i];
-			}
-		}
-	}
-
-	return NULL;
-}
-#endif  /* DUK_USE_HEAPPTR16 */
-
-#if defined(DUK_USE_HEAPPTR16)
-DUK_LOCAL void duk__remove_matching_hstring_chain(duk_heap *heap, duk_hstring *h) {
-	duk_small_uint_t slotidx;
-	duk_strtab_entry *e;
-	duk_uint16_t *lst;
-	duk_size_t i, n;
-	duk_uint16_t h16;
-	duk_uint16_t null16 = heap->heapptr_null16;
-
-	DUK_ASSERT(heap != NULL);
-	DUK_ASSERT(h != NULL);
-
-	slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE;
-	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-
-	DUK_ASSERT(h != NULL);
-	h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-
-	e = heap->strtable + slotidx;
-	if (e->listlen == 0) {
-		if (e->u.str16 == h16) {
-			e->u.str16 = null16;
-			return;
-		}
-	} else {
-		DUK_ASSERT(e->u.strlist16 != null16);
-		lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-		DUK_ASSERT(lst != NULL);
-		for (i = 0, n = e->listlen; i < n; i++) {
-			if (lst[i] == h16) {
-				lst[i] = null16;
-				return;
-			}
-		}
-	}
-
-	DUK_D(DUK_DPRINT("failed to find string that should be in stringtable"));
-	DUK_UNREACHABLE();
-	return;
-}
-#else  /* DUK_USE_HEAPPTR16 */
-DUK_LOCAL void duk__remove_matching_hstring_chain(duk_heap *heap, duk_hstring *h) {
-	duk_small_uint_t slotidx;
-	duk_strtab_entry *e;
-	duk_hstring **lst;
-	duk_size_t i, n;
-
-	DUK_ASSERT(heap != NULL);
-	DUK_ASSERT(h != NULL);
-
-	slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE;
-	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-
-	e = heap->strtable + slotidx;
-	if (e->listlen == 0) {
-		DUK_ASSERT(h != NULL);
-		if (e->u.str == h) {
-			e->u.str = NULL;
-			return;
-		}
-	} else {
-		DUK_ASSERT(e->u.strlist != NULL);
-		lst = e->u.strlist;
-		for (i = 0, n = e->listlen; i < n; i++) {
-			DUK_ASSERT(h != NULL);
-			if (lst[i] == h) {
-				lst[i] = NULL;
-				return;
-			}
-		}
-	}
-
-	DUK_D(DUK_DPRINT("failed to find string that should be in stringtable"));
-	DUK_UNREACHABLE();
-	return;
-}
-#endif  /* DUK_USE_HEAPPTR16 */
-
-#if defined(DUK_USE_DEBUG)
-DUK_INTERNAL void duk_heap_dump_strtab(duk_heap *heap) {
-	duk_strtab_entry *e;
-	duk_small_uint_t i;
-	duk_size_t j, n, used;
-#if defined(DUK_USE_HEAPPTR16)
-	duk_uint16_t *lst;
-	duk_uint16_t null16 = heap->heapptr_null16;
-#else
-	duk_hstring **lst;
-#endif
-
-	DUK_ASSERT(heap != NULL);
-
-	for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
-		e = heap->strtable + i;
-
-		if (e->listlen == 0) {
-#if defined(DUK_USE_HEAPPTR16)
-			DUK_DD(DUK_DDPRINT("[%03d] -> plain %d", (int) i, (int) (e->u.str16 != null16 ? 1 : 0)));
-#else
-			DUK_DD(DUK_DDPRINT("[%03d] -> plain %d", (int) i, (int) (e->u.str ? 1 : 0)));
-#endif
-		} else {
-			used = 0;
-#if defined(DUK_USE_HEAPPTR16)
-			lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-#else
-			lst = e->u.strlist;
-#endif
-			DUK_ASSERT(lst != NULL);
-			for (j = 0, n = e->listlen; j < n; j++) {
-#if defined(DUK_USE_HEAPPTR16)
-				if (lst[j] != null16) {
-#else
-				if (lst[j] != NULL) {
-#endif
-					used++;
-				}
-			}
-			DUK_DD(DUK_DDPRINT("[%03d] -> array %d/%d", (int) i, (int) used, (int) e->listlen));
-		}
-	}
-}
-#endif  /* DUK_USE_DEBUG */
-
-#endif  /* DUK_USE_STRTAB_CHAIN */
-
-/*
- *  String table algorithm: closed hashing with a probe sequence
- *
- *  This is the default algorithm and works fine for environments with
- *  minimal memory constraints.
- */
-
-#if defined(DUK_USE_STRTAB_PROBE)
-
-/* Count actually used (non-NULL, non-DELETED) entries. */
-DUK_LOCAL duk_int_t duk__count_used_probe(duk_heap *heap) {
-	duk_int_t res = 0;
-	duk_uint_fast32_t i, n;
-#if defined(DUK_USE_HEAPPTR16)
-	duk_uint16_t null16 = heap->heapptr_null16;
-	duk_uint16_t deleted16 = heap->heapptr_deleted16;
-#endif
-
-	n = (duk_uint_fast32_t) heap->st_size;
-	for (i = 0; i < n; i++) {
-#if defined(DUK_USE_HEAPPTR16)
-		if (heap->strtable16[i] != null16 && heap->strtable16[i] != deleted16) {
-#else
-		if (heap->strtable[i] != NULL && heap->strtable[i] != DUK__DELETED_MARKER(heap)) {
-#endif
-			res++;
-		}
-	}
-	return res;
-}
-
-#if defined(DUK_USE_HEAPPTR16)
-DUK_LOCAL void duk__insert_hstring_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, duk_uint32_t *p_used, duk_hstring *h) {
-#else
-DUK_LOCAL void duk__insert_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_uint32_t *p_used, duk_hstring *h) {
-#endif
-	duk_uint32_t i;
-	duk_uint32_t step;
-#if defined(DUK_USE_HEAPPTR16)
-	duk_uint16_t null16 = heap->heapptr_null16;
-	duk_uint16_t deleted16 = heap->heapptr_deleted16;
-#endif
-
-	DUK_ASSERT(size > 0);
-
-	i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size);
-	step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(h));
-	for (;;) {
-#if defined(DUK_USE_HEAPPTR16)
-		duk_uint16_t e16 = entries16[i];
-#else
-		duk_hstring *e = entries[i];
-#endif
-
-#if defined(DUK_USE_HEAPPTR16)
-		/* XXX: could check for e16 == 0 because NULL is guaranteed to
-		 * encode to zero.
-		 */
-		if (e16 == null16) {
-#else
-		if (e == NULL) {
-#endif
-			DUK_DDD(DUK_DDDPRINT("insert hit (null): %ld", (long) i));
-#if defined(DUK_USE_HEAPPTR16)
-			entries16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-#else
-			entries[i] = h;
-#endif
-			(*p_used)++;
-			break;
-#if defined(DUK_USE_HEAPPTR16)
-		} else if (e16 == deleted16) {
-#else
-		} else if (e == DUK__DELETED_MARKER(heap)) {
-#endif
-			/* st_used remains the same, DELETED is counted as used */
-			DUK_DDD(DUK_DDDPRINT("insert hit (deleted): %ld", (long) i));
-#if defined(DUK_USE_HEAPPTR16)
-			entries16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-#else
-			entries[i] = h;
-#endif
-			break;
-		}
-		DUK_DDD(DUK_DDDPRINT("insert miss: %ld", (long) i));
-		i = (i + step) % size;
-
-		/* looping should never happen */
-		DUK_ASSERT(i != DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size));
-	}
-}
-
-#if defined(DUK_USE_HEAPPTR16)
-DUK_LOCAL duk_hstring *duk__find_matching_string_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
-#else
-DUK_LOCAL duk_hstring *duk__find_matching_string_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
-#endif
-	duk_uint32_t i;
-	duk_uint32_t step;
-
-	DUK_ASSERT(size > 0);
-
-	i = DUK__HASH_INITIAL(strhash, size);
-	step = DUK__HASH_PROBE_STEP(strhash);
-	for (;;) {
-		duk_hstring *e;
-#if defined(DUK_USE_HEAPPTR16)
-		e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, entries16[i]);
-#else
-		e = entries[i];
-#endif
-
-		if (!e) {
-			return NULL;
-		}
-		if (e != DUK__DELETED_MARKER(heap) && DUK_HSTRING_GET_BYTELEN(e) == blen) {
-			if (DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(e), (size_t) blen) == 0) {
-				DUK_DDD(DUK_DDDPRINT("find matching hit: %ld (step %ld, size %ld)",
-				                     (long) i, (long) step, (long) size));
-				return e;
-			}
-		}
-		DUK_DDD(DUK_DDDPRINT("find matching miss: %ld (step %ld, size %ld)",
-		                     (long) i, (long) step, (long) size));
-		i = (i + step) % size;
-
-		/* looping should never happen */
-		DUK_ASSERT(i != DUK__HASH_INITIAL(strhash, size));
-	}
-	DUK_UNREACHABLE();
-}
-
-#if defined(DUK_USE_HEAPPTR16)
-DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, duk_hstring *h) {
-#else
-DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_hstring *h) {
-#endif
-	duk_uint32_t i;
-	duk_uint32_t step;
-	duk_uint32_t hash;
-#if defined(DUK_USE_HEAPPTR16)
-	duk_uint16_t null16 = heap->heapptr_null16;
-	duk_uint16_t h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-#endif
-
-	DUK_ASSERT(size > 0);
-
-	hash = DUK_HSTRING_GET_HASH(h);
-	i = DUK__HASH_INITIAL(hash, size);
-	step = DUK__HASH_PROBE_STEP(hash);
-	for (;;) {
-#if defined(DUK_USE_HEAPPTR16)
-		duk_uint16_t e16 = entries16[i];
-#else
-		duk_hstring *e = entries[i];
-#endif
-
-#if defined(DUK_USE_HEAPPTR16)
-		if (e16 == null16) {
-#else
-		if (!e) {
-#endif
-			DUK_UNREACHABLE();
-			break;
-		}
-#if defined(DUK_USE_HEAPPTR16)
-		if (e16 == h16) {
-#else
-		if (e == h) {
-#endif
-			/* st_used remains the same, DELETED is counted as used */
-			DUK_DDD(DUK_DDDPRINT("free matching hit: %ld", (long) i));
-#if defined(DUK_USE_HEAPPTR16)
-			entries16[i] = heap->heapptr_deleted16;
-#else
-			entries[i] = DUK__DELETED_MARKER(heap);
-#endif
-			break;
-		}
-
-		DUK_DDD(DUK_DDDPRINT("free matching miss: %ld", (long) i));
-		i = (i + step) % size;
-
-		/* looping should never happen */
-		DUK_ASSERT(i != DUK__HASH_INITIAL(hash, size));
-	}
-}
-
-DUK_LOCAL duk_bool_t duk__resize_strtab_raw_probe(duk_heap *heap, duk_uint32_t new_size) {
-#if defined(DUK_USE_DEBUG)
-	duk_uint32_t old_used = heap->st_used;
-#endif
-	duk_uint32_t old_size = heap->st_size;
-#if defined(DUK_USE_HEAPPTR16)
-	duk_uint16_t *old_entries = heap->strtable16;
-	duk_uint16_t *new_entries = NULL;
-#else
-	duk_hstring **old_entries = heap->strtable;
-	duk_hstring **new_entries = NULL;
-#endif
-	duk_uint32_t new_used = 0;
-	duk_uint32_t i;
-
-#if defined(DUK_USE_DEBUG)
-	DUK_UNREF(old_used);  /* unused with some debug level combinations */
-#endif
-
-#ifdef DUK_USE_DDDPRINT
-	DUK_DDD(DUK_DDDPRINT("attempt to resize stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load",
-	                     (long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used,
-	                     (long) (((double) old_used) / ((double) old_size) * 100.0),
-	                     (long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) duk__count_used_probe(heap),
-	                     (long) (((double) duk__count_used_probe(heap)) / ((double) new_size) * 100.0)));
-#endif
-
-	DUK_ASSERT(new_size > (duk_uint32_t) duk__count_used_probe(heap));  /* required for rehash to succeed, equality not that useful */
-	DUK_ASSERT(old_entries);
-
-	/*
-	 *  The attempt to allocate may cause a GC.  Such a GC must not attempt to resize
-	 *  the stringtable (though it can be swept); finalizer execution and object
-	 *  compaction must also be postponed to avoid the pressure to add strings to the
-	 *  string table.  Call site must prevent these.
-	 */
-
-#if defined(DUK_USE_MARK_AND_SWEEP)
-	DUK_ASSERT(heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE);
-	DUK_ASSERT(heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_FINALIZERS);
-	DUK_ASSERT(heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_OBJECT_COMPACTION);
-#endif
-
-#if defined(DUK_USE_HEAPPTR16)
-	new_entries = (duk_uint16_t *) DUK_ALLOC(heap, sizeof(duk_uint16_t) * new_size);
-#else
-	new_entries = (duk_hstring **) DUK_ALLOC(heap, sizeof(duk_hstring *) * new_size);
-#endif
-
-	if (!new_entries) {
-		goto resize_error;
-	}
-
-#if defined(DUK_USE_EXPLICIT_NULL_INIT)
-	for (i = 0; i < new_size; i++) {
-#if defined(DUK_USE_HEAPPTR16)
-		new_entries[i] = heap->heapptr_null16;
-#else
-		new_entries[i] = NULL;
-#endif
-	}
-#else
-#if defined(DUK_USE_HEAPPTR16)
-	/* Relies on NULL encoding to zero. */
-	DUK_MEMZERO(new_entries, sizeof(duk_uint16_t) * new_size);
-#else
-	DUK_MEMZERO(new_entries, sizeof(duk_hstring *) * new_size);
-#endif
-#endif
-
-	/* Because new_size > duk__count_used_probe(heap), guaranteed to work */
-	for (i = 0; i < old_size; i++) {
-		duk_hstring *e;
-
-#if defined(DUK_USE_HEAPPTR16)
-		e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, old_entries[i]);
-#else
-		e = old_entries[i];
-#endif
-		if (e == NULL || e == DUK__DELETED_MARKER(heap)) {
-			continue;
-		}
-		/* checking for DUK__DELETED_MARKER is not necessary here, but helper does it now */
-		duk__insert_hstring_probe(heap, new_entries, new_size, &new_used, e);
-	}
-
-#ifdef DUK_USE_DDPRINT
-	DUK_DD(DUK_DDPRINT("resized stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load",
-	                   (long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used,
-	                   (long) (((double) old_used) / ((double) old_size) * 100.0),
-	                   (long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) new_used,
-	                   (long) (((double) new_used) / ((double) new_size) * 100.0)));
-#endif
-
-#if defined(DUK_USE_HEAPPTR16)
-	DUK_FREE(heap, heap->strtable16);
-	heap->strtable16 = new_entries;
-#else
-	DUK_FREE(heap, heap->strtable);
-	heap->strtable = new_entries;
-#endif
-	heap->st_size = new_size;
-	heap->st_used = new_used;  /* may be less, since DELETED entries are NULLed by rehash */
-
-	return 0;  /* OK */
-
- resize_error:
-	DUK_FREE(heap, new_entries);
-	return 1;  /* FAIL */
-}
-
-DUK_LOCAL duk_bool_t duk__resize_strtab_probe(duk_heap *heap) {
-	duk_uint32_t new_size;
-	duk_bool_t ret;
-
-	new_size = (duk_uint32_t) duk__count_used_probe(heap);
-	if (new_size >= 0x80000000UL) {
-		new_size = DUK_STRTAB_HIGHEST_32BIT_PRIME;
-	} else {
-		new_size = duk_util_get_hash_prime(DUK_STRTAB_GROW_ST_SIZE(new_size));
-		new_size = duk_util_get_hash_prime(new_size);
-	}
-	DUK_ASSERT(new_size > 0);
-
-	/* rehash even if old and new sizes are the same to get rid of
-	 * DELETED entries.
-	*/
-
-	ret = duk__resize_strtab_raw_probe(heap, new_size);
-
-	return ret;
-}
-
-DUK_LOCAL duk_bool_t duk__recheck_strtab_size_probe(duk_heap *heap, duk_uint32_t new_used) {
-	duk_uint32_t new_free;
-	duk_uint32_t tmp1;
-	duk_uint32_t tmp2;
-
-	DUK_ASSERT(new_used <= heap->st_size);  /* grow by at most one */
-	new_free = heap->st_size - new_used;    /* unsigned intentionally */
-
-	/* new_free / size <= 1 / DIV  <=>  new_free <= size / DIV */
-	/* new_used / size <= 1 / DIV  <=>  new_used <= size / DIV */
-
-	tmp1 = heap->st_size / DUK_STRTAB_MIN_FREE_DIVISOR;
-	tmp2 = heap->st_size / DUK_STRTAB_MIN_USED_DIVISOR;
-
-	if (new_free <= tmp1 || new_used <= tmp2) {
-		/* load factor too low or high, count actually used entries and resize */
-		return duk__resize_strtab_probe(heap);
-	} else {
-		return 0;  /* OK */
-	}
-}
-
-#if defined(DUK_USE_DEBUG)
-DUK_INTERNAL void duk_heap_dump_strtab(duk_heap *heap) {
-	duk_uint32_t i;
-	duk_hstring *h;
-
-	DUK_ASSERT(heap != NULL);
-#if defined(DUK_USE_HEAPPTR16)
-	DUK_ASSERT(heap->strtable16 != NULL);
-#else
-	DUK_ASSERT(heap->strtable != NULL);
-#endif
-	DUK_UNREF(h);
-
-	for (i = 0; i < heap->st_size; i++) {
-#if defined(DUK_USE_HEAPPTR16)
-		h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->strtable16[i]);
-#else
-		h = heap->strtable[i];
-#endif
-
-		DUK_DD(DUK_DDPRINT("[%03d] -> %p", (int) i, (void *) h));
-	}
-}
-#endif  /* DUK_USE_DEBUG */
-
-#endif  /* DUK_USE_STRTAB_PROBE */
-
-/*
- *  Raw intern and lookup
- */
-
-DUK_LOCAL duk_hstring *duk__do_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
-	duk_hstring *res;
-	const duk_uint8_t *extdata;
-#if defined(DUK_USE_MARK_AND_SWEEP)
-	duk_small_uint_t prev_mark_and_sweep_base_flags;
-#endif
-
-	/* Prevent any side effects on the string table and the caller provided
-	 * str/blen arguments while interning is in progress.  For example, if
-	 * the caller provided str/blen from a dynamic buffer, a finalizer might
-	 * resize that dynamic buffer, invalidating the call arguments.
-	 */
-#if defined(DUK_USE_MARK_AND_SWEEP)
-	DUK_ASSERT((heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE) == 0);
-	prev_mark_and_sweep_base_flags = heap->mark_and_sweep_base_flags;
-	DUK__PREVENT_MS_SIDE_EFFECTS(heap);
-#endif
-
-#if defined(DUK_USE_STRTAB_PROBE)
-	if (duk__recheck_strtab_size_probe(heap, heap->st_used + 1)) {
-		goto failed;
-	}
-#endif
-
-	/* For manual testing only. */
-#if 0
-	{
-		duk_size_t i;
-		DUK_PRINTF("INTERN: \"");
-		for (i = 0; i < blen; i++) {
-			duk_uint8_t x = str[i];
-			if (x >= 0x20 && x <= 0x7e && x != '"' && x != '\\') {
-				DUK_PRINTF("%c", (int) x);  /* char: use int cast */
-			} else {
-				DUK_PRINTF("\\x%02lx", (long) x);
-			}
-		}
-		DUK_PRINTF("\"\n");
-	}
-#endif
-
-#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_INTERN_CHECK)
-	extdata = (const duk_uint8_t *) DUK_USE_EXTSTR_INTERN_CHECK(heap->heap_udata, (void *) DUK_LOSE_CONST(str), (duk_size_t) blen);
-#else
-	extdata = (const duk_uint8_t *) NULL;
-#endif
-	res = duk__alloc_init_hstring(heap, str, blen, strhash, extdata);
-	if (!res) {
-		goto failed;
-	}
-
-#if defined(DUK_USE_STRTAB_CHAIN)
-	if (duk__insert_hstring_chain(heap, res)) {
-		/* failed */
-		DUK_FREE(heap, res);
-		goto failed;
-	}
-#elif defined(DUK_USE_STRTAB_PROBE)
-	/* guaranteed to succeed */
-	duk__insert_hstring_probe(heap,
-#if defined(DUK_USE_HEAPPTR16)
-	                          heap->strtable16,
-#else
-	                          heap->strtable,
-#endif
-	                          heap->st_size,
-	                          &heap->st_used,
-	                          res);
-#else
-#error internal error, invalid strtab options
-#endif
-
-	/* Note: hstring is in heap but has refcount zero and is not strongly reachable.
-	 * Caller should increase refcount and make the hstring reachable before any
-	 * operations which require allocation (and possible gc).
-	 */
-
- done:
-#if defined(DUK_USE_MARK_AND_SWEEP)
-	heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
-#endif
-	return res;
-
- failed:
-	res = NULL;
-	goto done;
-}
-
-DUK_LOCAL duk_hstring *duk__do_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t *out_strhash) {
-	duk_hstring *res;
-
-	DUK_ASSERT(out_strhash);
-
-	*out_strhash = duk_heap_hashstring(heap, str, (duk_size_t) blen);
-
-#if defined(DUK_USE_ROM_STRINGS)
-	{
-		duk_small_uint_t i;
-		/* XXX: This is VERY inefficient now, and should be e.g. a
-		 * binary search or perfect hash, to be fixed.
-		 */
-		for (i = 0; i < (duk_small_uint_t) (sizeof(duk_rom_strings) / sizeof(duk_hstring *)); i++) {
-			duk_hstring *romstr;
-			romstr = (duk_hstring *) DUK_LOSE_CONST(duk_rom_strings[i]);
-			if (blen == DUK_HSTRING_GET_BYTELEN(romstr) &&
-			    DUK_MEMCMP((const void *) str, (const void *) DUK_HSTRING_GET_DATA(romstr), blen) == 0) {
-				DUK_DD(DUK_DDPRINT("intern check: rom string: %!O, computed hash 0x%08lx, rom hash 0x%08lx",
-				                   romstr, (unsigned long) *out_strhash, (unsigned long) DUK_HSTRING_GET_HASH(romstr)));
-				DUK_ASSERT(*out_strhash == DUK_HSTRING_GET_HASH(romstr));
-				*out_strhash = DUK_HSTRING_GET_HASH(romstr);
-				return romstr;
-			}
-		}
-	}
-#endif  /* DUK_USE_ROM_STRINGS */
-
-#if defined(DUK_USE_STRTAB_CHAIN)
-	res = duk__find_matching_string_chain(heap, str, blen, *out_strhash);
-#elif defined(DUK_USE_STRTAB_PROBE)
-	res = duk__find_matching_string_probe(heap,
-#if defined(DUK_USE_HEAPPTR16)
-	                                      heap->strtable16,
-#else
-	                                      heap->strtable,
-#endif
-	                                      heap->st_size,
-	                                      str,
-	                                      blen,
-	                                      *out_strhash);
-#else
-#error internal error, invalid strtab options
-#endif
-
-	return res;
-}
-
-/*
- *  Exposed calls
- */
-
-#if 0  /*unused*/
-DUK_INTERNAL duk_hstring *duk_heap_string_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen) {
-	duk_uint32_t strhash;  /* dummy */
-	return duk__do_lookup(heap, str, blen, &strhash);
-}
-#endif
-
-DUK_INTERNAL duk_hstring *duk_heap_string_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen) {
-	duk_hstring *res;
-	duk_uint32_t strhash;
-
-	/* caller is responsible for ensuring this */
-	DUK_ASSERT(blen <= DUK_HSTRING_MAX_BYTELEN);
-
-	res = duk__do_lookup(heap, str, blen, &strhash);
-	if (res) {
-		return res;
-	}
-
-	res = duk__do_intern(heap, str, blen, strhash);
-	return res;  /* may be NULL */
-}
-
-DUK_INTERNAL duk_hstring *duk_heap_string_intern_checked(duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t blen) {
-	duk_hstring *res = duk_heap_string_intern(thr->heap, str, blen);
-	if (!res) {
-		DUK_ERROR_ALLOC_DEFMSG(thr);
-	}
-	return res;
-}
-
-#if 0  /*unused*/
-DUK_INTERNAL duk_hstring *duk_heap_string_lookup_u32(duk_heap *heap, duk_uint32_t val) {
-	char buf[DUK_STRTAB_U32_MAX_STRLEN+1];
-	DUK_SNPRINTF(buf, sizeof(buf), "%lu", (unsigned long) val);
-	buf[sizeof(buf) - 1] = (char) 0;
-	DUK_ASSERT(DUK_STRLEN(buf) <= DUK_UINT32_MAX);  /* formatted result limited */
-	return duk_heap_string_lookup(heap, (const duk_uint8_t *) buf, (duk_uint32_t) DUK_STRLEN(buf));
-}
-#endif
-
-DUK_INTERNAL duk_hstring *duk_heap_string_intern_u32(duk_heap *heap, duk_uint32_t val) {
-	char buf[DUK_STRTAB_U32_MAX_STRLEN+1];
-	DUK_SNPRINTF(buf, sizeof(buf), "%lu", (unsigned long) val);
-	buf[sizeof(buf) - 1] = (char) 0;
-	DUK_ASSERT(DUK_STRLEN(buf) <= DUK_UINT32_MAX);  /* formatted result limited */
-	return duk_heap_string_intern(heap, (const duk_uint8_t *) buf, (duk_uint32_t) DUK_STRLEN(buf));
-}
-
-DUK_INTERNAL duk_hstring *duk_heap_string_intern_u32_checked(duk_hthread *thr, duk_uint32_t val) {
-	duk_hstring *res = duk_heap_string_intern_u32(thr->heap, val);
-	if (!res) {
-		DUK_ERROR_ALLOC_DEFMSG(thr);
-	}
-	return res;
-}
-
-/* find and remove string from stringtable; caller must free the string itself */
-#if defined(DUK_USE_REFERENCE_COUNTING)
-DUK_INTERNAL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h) {
-	DUK_DDD(DUK_DDDPRINT("remove string from stringtable: %!O", (duk_heaphdr *) h));
-
-#if defined(DUK_USE_STRTAB_CHAIN)
-	duk__remove_matching_hstring_chain(heap, h);
-#elif defined(DUK_USE_STRTAB_PROBE)
-	duk__remove_matching_hstring_probe(heap,
-#if defined(DUK_USE_HEAPPTR16)
-	                                   heap->strtable16,
-#else
-	                                   heap->strtable,
-#endif
-	                                   heap->st_size,
-	                                   h);
-#else
-#error internal error, invalid strtab options
-#endif
-}
-#endif
-
-#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_MS_STRINGTABLE_RESIZE)
-DUK_INTERNAL void duk_heap_force_strtab_resize(duk_heap *heap) {
-	duk_small_uint_t prev_mark_and_sweep_base_flags;
-	/* Force a resize so that DELETED entries are eliminated.
-	 * Another option would be duk__recheck_strtab_size_probe();
-	 * but since that happens on every intern anyway, this whole
-	 * check can now be disabled.
-	 */
-
-	DUK_ASSERT((heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE) == 0);
-	prev_mark_and_sweep_base_flags = heap->mark_and_sweep_base_flags;
-	DUK__PREVENT_MS_SIDE_EFFECTS(heap);
-
-#if defined(DUK_USE_STRTAB_CHAIN)
-	DUK_UNREF(heap);
-#elif defined(DUK_USE_STRTAB_PROBE)
-	(void) duk__resize_strtab_probe(heap);
-#endif
-
-	heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
-}
-#endif
-
-#if defined(DUK_USE_STRTAB_CHAIN)
-DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap) {
-	/* Free strings in the stringtable and any allocations needed
-	 * by the stringtable itself.
-	 */
-	duk_uint_fast32_t i, j;
-	duk_strtab_entry *e;
-#if defined(DUK_USE_HEAPPTR16)
-	duk_uint16_t *lst;
-	duk_uint16_t null16 = heap->heapptr_null16;
-#else
-	duk_hstring **lst;
-#endif
-	duk_hstring *h;
-
-	for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
-		e = heap->strtable + i;
-		if (e->listlen > 0) {
-#if defined(DUK_USE_HEAPPTR16)
-			lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-#else
-			lst = e->u.strlist;
-#endif
-			DUK_ASSERT(lst != NULL);
-
-			for (j = 0; j < e->listlen; j++) {
-#if defined(DUK_USE_HEAPPTR16)
-				h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, lst[j]);
-				lst[j] = null16;
-#else
-				h = lst[j];
-				lst[j] = NULL;
-#endif
-				/* strings may have inner refs (extdata) in some cases */
-				if (h != NULL) {
-					duk_free_hstring_inner(heap, h);
-					DUK_FREE(heap, h);
-				}
-			}
-#if defined(DUK_USE_HEAPPTR16)
-			e->u.strlist16 = null16;
-#else
-			e->u.strlist = NULL;
-#endif
-			DUK_FREE(heap, lst);
-		} else {
-#if defined(DUK_USE_HEAPPTR16)
-			h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.str16);
-			e->u.str16 = null16;
-#else
-			h = e->u.str;
-			e->u.str = NULL;
-#endif
-			if (h != NULL) {
-				duk_free_hstring_inner(heap, h);
-				DUK_FREE(heap, h);
-			}
-		}
-		e->listlen = 0;
-	}
-}
-#endif  /* DUK_USE_STRTAB_CHAIN */
-
-#if defined(DUK_USE_STRTAB_PROBE)
-DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap) {
-	duk_uint_fast32_t i;
-	duk_hstring *h;
-
-#if defined(DUK_USE_HEAPPTR16)
-	if (heap->strtable16) {
-#else
-	if (heap->strtable) {
-#endif
-		for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) {
-#if defined(DUK_USE_HEAPPTR16)
-			h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, heap->strtable16[i]);
-#else
-			h = heap->strtable[i];
-#endif
-			if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {
-				continue;
-			}
-			DUK_ASSERT(h != NULL);
-
-			/* strings may have inner refs (extdata) in some cases */
-			duk_free_hstring_inner(heap, h);
-			DUK_FREE(heap, h);
-#if 0  /* not strictly necessary */
-			heap->strtable[i] = NULL;
-#endif
-		}
-#if defined(DUK_USE_HEAPPTR16)
-		DUK_FREE(heap, heap->strtable16);
-#else
-		DUK_FREE(heap, heap->strtable);
-#endif
-#if 0  /* not strictly necessary */
-		heap->strtable = NULL;
-#endif
-	}
-}
-#endif  /* DUK_USE_STRTAB_PROBE */
-
-/* Undefine local defines */
-#undef DUK__HASH_INITIAL
-#undef DUK__HASH_PROBE_STEP
-#undef DUK__DELETED_MARKER

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_heaphdr.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heaphdr.h b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heaphdr.h
deleted file mode 100644
index d489032..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_heaphdr.h
+++ /dev/null
@@ -1,750 +0,0 @@
-/*
- *  Heap header definition and assorted macros, including ref counting.
- *  Access all fields through the accessor macros.
- */
-
-#ifndef DUK_HEAPHDR_H_INCLUDED
-#define DUK_HEAPHDR_H_INCLUDED
-
-/*
- *  Common heap header
- *
- *  All heap objects share the same flags and refcount fields.  Objects other
- *  than strings also need to have a single or double linked list pointers
- *  for insertion into the "heap allocated" list.  Strings are held in the
- *  heap-wide string table so they don't need link pointers.
- *
- *  Technically, 'h_refcount' must be wide enough to guarantee that it cannot
- *  wrap (otherwise objects might be freed incorrectly after wrapping).  This
- *  means essentially that the refcount field must be as wide as data pointers.
- *  On 64-bit platforms this means that the refcount needs to be 64 bits even
- *  if an 'int' is 32 bits.  This is a bit unfortunate, and compromising on
- *  this might be reasonable in the future.
- *
- *  Heap header size on 32-bit platforms: 8 bytes without reference counting,
- *  16 bytes with reference counting.
- */
-
-struct duk_heaphdr {
-	duk_uint32_t h_flags;
-
-#if defined(DUK_USE_REFERENCE_COUNTING)
-#if defined(DUK_USE_REFCOUNT16)
-	duk_uint16_t h_refcount16;
-#else
-	duk_size_t h_refcount;
-#endif
-#endif
-
-#if defined(DUK_USE_HEAPPTR16)
-	duk_uint16_t h_next16;
-#else
-	duk_heaphdr *h_next;
-#endif
-
-#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
-	/* refcounting requires direct heap frees, which in turn requires a dual linked heap */
-#if defined(DUK_USE_HEAPPTR16)
-	duk_uint16_t h_prev16;
-#else
-	duk_heaphdr *h_prev;
-#endif
-#endif
-
-	/* When DUK_USE_HEAPPTR16 (and DUK_USE_REFCOUNT16) is in use, the
-	 * struct won't align nicely to 4 bytes.  This 16-bit extra field
-	 * is added to make the alignment clean; the field can be used by
-	 * heap objects when 16-bit packing is used.  This field is now
-	 * conditional to DUK_USE_HEAPPTR16 only, but it is intended to be
-	 * used with DUK_USE_REFCOUNT16 and DUK_USE_DOUBLE_LINKED_HEAP;
-	 * this only matter to low memory environments anyway.
-	 */
-#if defined(DUK_USE_HEAPPTR16)
-	duk_uint16_t h_extra16;
-#endif
-};
-
-struct duk_heaphdr_string {
-	/* 16 bits would be enough for shared heaphdr flags and duk_hstring
-	 * flags.  The initial parts of duk_heaphdr_string and duk_heaphdr
-	 * must match so changing the flags field size here would be quite
-	 * awkward.  However, to minimize struct size, we can pack at least
-	 * 16 bits of duk_hstring data into the flags field.
-	 */
-	duk_uint32_t h_flags;
-
-#if defined(DUK_USE_REFERENCE_COUNTING)
-#if defined(DUK_USE_REFCOUNT16)
-	duk_uint16_t h_refcount16;
-	duk_uint16_t h_strextra16;  /* round out to 8 bytes */
-#else
-	duk_size_t h_refcount;
-#endif
-#endif
-};
-
-#define DUK_HEAPHDR_FLAGS_TYPE_MASK      0x00000003UL
-#define DUK_HEAPHDR_FLAGS_FLAG_MASK      (~DUK_HEAPHDR_FLAGS_TYPE_MASK)
-
-                                             /* 2 bits for heap type */
-#define DUK_HEAPHDR_FLAGS_HEAP_START     2   /* 5 heap flags */
-#define DUK_HEAPHDR_FLAGS_USER_START     7   /* 25 user flags */
-
-#define DUK_HEAPHDR_HEAP_FLAG_NUMBER(n)  (DUK_HEAPHDR_FLAGS_HEAP_START + (n))
-#define DUK_HEAPHDR_USER_FLAG_NUMBER(n)  (DUK_HEAPHDR_FLAGS_USER_START + (n))
-#define DUK_HEAPHDR_HEAP_FLAG(n)         (1UL << (DUK_HEAPHDR_FLAGS_HEAP_START + (n)))
-#define DUK_HEAPHDR_USER_FLAG(n)         (1UL << (DUK_HEAPHDR_FLAGS_USER_START + (n)))
-
-#define DUK_HEAPHDR_FLAG_REACHABLE       DUK_HEAPHDR_HEAP_FLAG(0)  /* mark-and-sweep: reachable */
-#define DUK_HEAPHDR_FLAG_TEMPROOT        DUK_HEAPHDR_HEAP_FLAG(1)  /* mark-and-sweep: children not processed */
-#define DUK_HEAPHDR_FLAG_FINALIZABLE     DUK_HEAPHDR_HEAP_FLAG(2)  /* mark-and-sweep: finalizable (on current pass) */
-#define DUK_HEAPHDR_FLAG_FINALIZED       DUK_HEAPHDR_HEAP_FLAG(3)  /* mark-and-sweep: finalized (on previous pass) */
-#define DUK_HEAPHDR_FLAG_READONLY        DUK_HEAPHDR_HEAP_FLAG(4)  /* read-only object, in code section */
-
-#define DUK_HTYPE_MIN                    1
-#define DUK_HTYPE_STRING                 1
-#define DUK_HTYPE_OBJECT                 2
-#define DUK_HTYPE_BUFFER                 3
-#define DUK_HTYPE_MAX                    3
-
-#if defined(DUK_USE_HEAPPTR16)
-#define DUK_HEAPHDR_GET_NEXT(heap,h) \
-	((duk_heaphdr *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->h_next16))
-#define DUK_HEAPHDR_SET_NEXT(heap,h,val)   do { \
-		(h)->h_next16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) val); \
-	} while (0)
-#else
-#define DUK_HEAPHDR_GET_NEXT(heap,h)  ((h)->h_next)
-#define DUK_HEAPHDR_SET_NEXT(heap,h,val)   do { \
-		(h)->h_next = (val); \
-	} while (0)
-#endif
-
-#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
-#if defined(DUK_USE_HEAPPTR16)
-#define DUK_HEAPHDR_GET_PREV(heap,h) \
-	((duk_heaphdr *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->h_prev16))
-#define DUK_HEAPHDR_SET_PREV(heap,h,val)   do { \
-		(h)->h_prev16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (val)); \
-	} while (0)
-#else
-#define DUK_HEAPHDR_GET_PREV(heap,h)       ((h)->h_prev)
-#define DUK_HEAPHDR_SET_PREV(heap,h,val)   do { \
-		(h)->h_prev = (val); \
-	} while (0)
-#endif
-#endif
-
-#if defined(DUK_USE_REFERENCE_COUNTING)
-#if defined(DUK_USE_REFCOUNT16)
-#define DUK_HEAPHDR_GET_REFCOUNT(h)   ((h)->h_refcount16)
-#define DUK_HEAPHDR_SET_REFCOUNT(h,val)  do { \
-		(h)->h_refcount16 = (val); \
-	} while (0)
-#define DUK_HEAPHDR_PREINC_REFCOUNT(h)  (++(h)->h_refcount16)  /* result: updated refcount */
-#define DUK_HEAPHDR_PREDEC_REFCOUNT(h)  (--(h)->h_refcount16)  /* result: updated refcount */
-#else
-#define DUK_HEAPHDR_GET_REFCOUNT(h)   ((h)->h_refcount)
-#define DUK_HEAPHDR_SET_REFCOUNT(h,val)  do { \
-		(h)->h_refcount = (val); \
-	} while (0)
-#define DUK_HEAPHDR_PREINC_REFCOUNT(h)  (++(h)->h_refcount)  /* result: updated refcount */
-#define DUK_HEAPHDR_PREDEC_REFCOUNT(h)  (--(h)->h_refcount)  /* result: updated refcount */
-#endif
-#else
-/* refcount macros not defined without refcounting, caller must #ifdef now */
-#endif  /* DUK_USE_REFERENCE_COUNTING */
-
-/*
- *  Note: type is treated as a field separate from flags, so some masking is
- *  involved in the macros below.
- */
-
-#define DUK_HEAPHDR_GET_FLAGS_RAW(h)  ((h)->h_flags)
-
-#define DUK_HEAPHDR_GET_FLAGS(h)      ((h)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK)
-#define DUK_HEAPHDR_SET_FLAGS(h,val)  do { \
-		(h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) | (val); \
-	} while (0)
-
-#define DUK_HEAPHDR_GET_TYPE(h)       ((h)->h_flags & DUK_HEAPHDR_FLAGS_TYPE_MASK)
-#define DUK_HEAPHDR_SET_TYPE(h,val)   do { \
-		(h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_TYPE_MASK)) | (val); \
-	} while (0)
-
-#define DUK_HEAPHDR_HTYPE_VALID(h)    ( \
-	DUK_HEAPHDR_GET_TYPE((h)) >= DUK_HTYPE_MIN && \
-	DUK_HEAPHDR_GET_TYPE((h)) <= DUK_HTYPE_MAX \
-	)
-
-#define DUK_HEAPHDR_SET_TYPE_AND_FLAGS(h,tval,fval)  do { \
-		(h)->h_flags = ((tval) & DUK_HEAPHDR_FLAGS_TYPE_MASK) | \
-		               ((fval) & DUK_HEAPHDR_FLAGS_FLAG_MASK); \
-	} while (0)
-
-#define DUK_HEAPHDR_SET_FLAG_BITS(h,bits)  do { \
-		DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
-		(h)->h_flags |= (bits); \
-	} while (0)
-
-#define DUK_HEAPHDR_CLEAR_FLAG_BITS(h,bits)  do { \
-		DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
-		(h)->h_flags &= ~((bits)); \
-	} while (0)
-
-#define DUK_HEAPHDR_CHECK_FLAG_BITS(h,bits)  (((h)->h_flags & (bits)) != 0)
-
-#define DUK_HEAPHDR_SET_REACHABLE(h)      DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
-#define DUK_HEAPHDR_CLEAR_REACHABLE(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
-#define DUK_HEAPHDR_HAS_REACHABLE(h)      DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
-
-#define DUK_HEAPHDR_SET_TEMPROOT(h)       DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
-#define DUK_HEAPHDR_CLEAR_TEMPROOT(h)     DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
-#define DUK_HEAPHDR_HAS_TEMPROOT(h)       DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
-
-#define DUK_HEAPHDR_SET_FINALIZABLE(h)    DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
-#define DUK_HEAPHDR_CLEAR_FINALIZABLE(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
-#define DUK_HEAPHDR_HAS_FINALIZABLE(h)    DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
-
-#define DUK_HEAPHDR_SET_FINALIZED(h)      DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
-#define DUK_HEAPHDR_CLEAR_FINALIZED(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
-#define DUK_HEAPHDR_HAS_FINALIZED(h)      DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
-
-#define DUK_HEAPHDR_SET_READONLY(h)       DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
-#define DUK_HEAPHDR_CLEAR_READONLY(h)     DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
-#define DUK_HEAPHDR_HAS_READONLY(h)       DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
-
-/* get or set a range of flags; m=first bit number, n=number of bits */
-#define DUK_HEAPHDR_GET_FLAG_RANGE(h,m,n)  (((h)->h_flags >> (m)) & ((1UL << (n)) - 1UL))
-
-#define DUK_HEAPHDR_SET_FLAG_RANGE(h,m,n,v)  do { \
-		(h)->h_flags = \
-			((h)->h_flags & (~(((1 << (n)) - 1) << (m)))) \
-			| ((v) << (m)); \
-	} while (0)
-
-/* init pointer fields to null */
-#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
-#define DUK_HEAPHDR_INIT_NULLS(h)       do { \
-		DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
-		DUK_HEAPHDR_SET_PREV((h), (void *) NULL); \
-	} while (0)
-#else
-#define DUK_HEAPHDR_INIT_NULLS(h)       do { \
-		DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
-	} while (0)
-#endif
-
-#define DUK_HEAPHDR_STRING_INIT_NULLS(h)  /* currently nop */
-
-/*
- *  Assert helpers
- */
-
-/* Check that prev/next links are consistent: if e.g. h->prev is != NULL,
- * h->prev->next should point back to h.
- */
-#if defined(DUK_USE_DOUBLE_LINKED_HEAP) && defined(DUK_USE_ASSERTIONS)
-#define DUK_ASSERT_HEAPHDR_LINKS(heap,h) do { \
-		if ((h) != NULL) { \
-			duk_heaphdr *h__prev, *h__next; \
-			h__prev = DUK_HEAPHDR_GET_PREV((heap), (h)); \
-			h__next = DUK_HEAPHDR_GET_NEXT((heap), (h)); \
-			DUK_ASSERT(h__prev == NULL || (DUK_HEAPHDR_GET_NEXT((heap), h__prev) == (h))); \
-			DUK_ASSERT(h__next == NULL || (DUK_HEAPHDR_GET_PREV((heap), h__next) == (h))); \
-		} \
-	} while (0)
-#else
-#define DUK_ASSERT_HEAPHDR_LINKS(heap,h) do {} while (0)
-#endif
-
-/*
- *  Reference counting helper macros.  The macros take a thread argument
- *  and must thus always be executed in a specific thread context.  The
- *  thread argument is needed for features like finalization.  Currently
- *  it is not required for INCREF, but it is included just in case.
- *
- *  Note that 'raw' macros such as DUK_HEAPHDR_GET_REFCOUNT() are not
- *  defined without DUK_USE_REFERENCE_COUNTING, so caller must #ifdef
- *  around them.
- */
-
-#if defined(DUK_USE_REFERENCE_COUNTING)
-
-#if defined(DUK_USE_ROM_OBJECTS)
-/* With ROM objects "needs refcount update" is true when the value is
- * heap allocated and is not a ROM object.
- */
-/* XXX: double evaluation for 'tv' argument. */
-#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv) \
-	(DUK_TVAL_IS_HEAP_ALLOCATED((tv)) && !DUK_HEAPHDR_HAS_READONLY(DUK_TVAL_GET_HEAPHDR((tv))))
-#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h)  (!DUK_HEAPHDR_HAS_READONLY((h)))
-#else  /* DUK_USE_ROM_OBJECTS */
-/* Without ROM objects "needs refcount update" == is heap allocated. */
-#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv)    DUK_TVAL_IS_HEAP_ALLOCATED((tv))
-#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h)  1
-#endif  /* DUK_USE_ROM_OBJECTS */
-
-/* Fast variants, inline refcount operations except for refzero handling.
- * Can be used explicitly when speed is always more important than size.
- * For a good compiler and a single file build, these are basically the
- * same as a forced inline.
- */
-#define DUK_TVAL_INCREF_FAST(thr,tv) do { \
-		duk_tval *duk__tv = (tv); \
-		DUK_ASSERT(duk__tv != NULL); \
-		if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
-			duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
-			DUK_ASSERT(duk__h != NULL); \
-			DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
-			DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
-		} \
-	} while (0)
-#define DUK_TVAL_DECREF_FAST(thr,tv) do { \
-		duk_tval *duk__tv = (tv); \
-		DUK_ASSERT(duk__tv != NULL); \
-		if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
-			duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
-			DUK_ASSERT(duk__h != NULL); \
-			DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
-			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
-			if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
-				duk_heaphdr_refzero((thr), duk__h); \
-			} \
-		} \
-	} while (0)
-#define DUK_HEAPHDR_INCREF_FAST(thr,h) do { \
-		duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
-		DUK_ASSERT(duk__h != NULL); \
-		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
-		if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
-			DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
-		} \
-	} while (0)
-#define DUK_HEAPHDR_DECREF_FAST(thr,h) do { \
-		duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
-		DUK_ASSERT(duk__h != NULL); \
-		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
-		DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
-		if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
-			if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
-				duk_heaphdr_refzero((thr), duk__h); \
-			} \
-		} \
-	} while (0)
-
-/* Slow variants, call to a helper to reduce code size.
- * Can be used explicitly when size is always more important than speed.
- */
-#define DUK_TVAL_INCREF_SLOW(thr,tv) do { \
-		duk_tval_incref((tv)); \
-	} while (0)
-#define DUK_TVAL_DECREF_SLOW(thr,tv) do { \
-		duk_tval_decref((thr), (tv)); \
-	} while (0)
-#define DUK_HEAPHDR_INCREF_SLOW(thr,h) do { \
-		duk_heaphdr_incref((duk_heaphdr *) (h)); \
-	} while (0)
-#define DUK_HEAPHDR_DECREF_SLOW(thr,h) do { \
-		duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \
-	} while (0)
-
-/* Default variants.  Selection depends on speed/size preference.
- * Concretely: with gcc 4.8.1 -Os x64 the difference in final binary
- * is about +1kB for _FAST variants.
- */
-#if defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
-#define DUK_TVAL_INCREF(thr,tv)                DUK_TVAL_INCREF_FAST((thr),(tv))
-#define DUK_TVAL_DECREF(thr,tv)                DUK_TVAL_DECREF_FAST((thr),(tv))
-#define DUK_HEAPHDR_INCREF(thr,h)              DUK_HEAPHDR_INCREF_FAST((thr),(h))
-#define DUK_HEAPHDR_DECREF(thr,h)              DUK_HEAPHDR_DECREF_FAST((thr),(h))
-#else
-#define DUK_TVAL_INCREF(thr,tv)                DUK_TVAL_INCREF_SLOW((thr),(tv))
-#define DUK_TVAL_DECREF(thr,tv)                DUK_TVAL_DECREF_SLOW((thr),(tv))
-#define DUK_HEAPHDR_INCREF(thr,h)              DUK_HEAPHDR_INCREF_SLOW((thr),(h))
-#define DUK_HEAPHDR_DECREF(thr,h)              DUK_HEAPHDR_DECREF_SLOW((thr),(h))
-#endif
-
-/* Casting convenience. */
-#define DUK_HSTRING_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-#define DUK_HSTRING_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
-#define DUK_HOBJECT_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-#define DUK_HOBJECT_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
-#define DUK_HBUFFER_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-#define DUK_HBUFFER_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
-#define DUK_HCOMPILEDFUNCTION_INCREF(thr,h)    DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HCOMPILEDFUNCTION_DECREF(thr,h)    DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HNATIVEFUNCTION_INCREF(thr,h)      DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HNATIVEFUNCTION_DECREF(thr,h)      DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HBUFFEROBJECT_INCREF(thr,h)        DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HBUFFEROBJECT_DECREF(thr,h)        DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HTHREAD_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HTHREAD_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
-
-/* Convenience for some situations; the above macros don't allow NULLs
- * for performance reasons.
- */
-#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do { \
-		if ((h) != NULL) { \
-			DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)); \
-		} \
-	} while (0)
-#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do { \
-		if ((h) != NULL) { \
-			DUK_HEAPHDR_DECREF((thr), (duk_heaphdr *) (h)); \
-		} \
-	} while (0)
-
-/*
- *  Macros to set a duk_tval and update refcount of the target (decref the
- *  old value and incref the new value if necessary).  This is both performance
- *  and footprint critical; any changes made should be measured for size/speed.
- */
-
-#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_UNDEFINED(tv__dst); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-
-#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_UNUSED(tv__dst); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-
-#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_NULL(tv__dst); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-
-#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-
-#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_NUMBER_CHKFAST(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_NAN(tv__dst); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-#if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_SET_FASTINT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_FASTINT(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-#define DUK_TVAL_SET_FASTINT_I32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_FASTINT_I32(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-#define DUK_TVAL_SET_FASTINT_U32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_FASTINT_U32(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-#else
-#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr,tvptr_dst,newval) \
-	DUK_TVAL_SET_DOUBLE_UPDREF((thr), (tvptr_dst), (duk_double_t) (newval))
-#endif  /* DUK_USE_FASTINT */
-
-#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr,tvptr_dst,lf_v,lf_fp,lf_flags) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-
-#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_STRING(tv__dst, (newval)); \
-		DUK_HSTRING_INCREF((thr), (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-
-#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \
-		DUK_HOBJECT_INCREF((thr), (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-
-#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \
-		DUK_HBUFFER_INCREF((thr), (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-
-#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_POINTER(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-
-/* DUK_TVAL_SET_TVAL_UPDREF() is used a lot in executor, property lookups,
- * etc, so it's very important for performance.  Measure when changing.
- *
- * NOTE: the source and destination duk_tval pointers may be the same, and
- * the macros MUST deal with that correctly.
- */
-
-/* Original idiom used, minimal code size. */
-#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr,tvptr_dst,tvptr_src) do { \
-		duk_tval *tv__dst, *tv__src; duk_tval tv__tmp; \
-		tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
-		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
-		DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
-		DUK_TVAL_INCREF((thr), tv__src); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
-	} while (0)
-
-/* Faster alternative: avoid making a temporary copy of tvptr_dst and use
- * fast incref/decref macros.
- */
-#define DUK_TVAL_SET_TVAL_UPDREF_ALT1(thr,tvptr_dst,tvptr_src) do { \
-		duk_tval *tv__dst, *tv__src; duk_heaphdr *h__obj; \
-		tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
-		DUK_TVAL_INCREF_FAST((thr), tv__src); \
-		if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv__dst)) { \
-			h__obj = DUK_TVAL_GET_HEAPHDR(tv__dst); \
-			DUK_ASSERT(h__obj != NULL); \
-			DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
-			DUK_HEAPHDR_DECREF_FAST((thr), h__obj);  /* side effects */ \
-		} else { \
-			DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
-		} \
-	} while (0)
-
-/* XXX: no optimized variants yet */
-#define DUK_TVAL_SET_UNDEFINED_UPDREF         DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
-#define DUK_TVAL_SET_UNUSED_UPDREF            DUK_TVAL_SET_UNUSED_UPDREF_ALT0
-#define DUK_TVAL_SET_NULL_UPDREF              DUK_TVAL_SET_NULL_UPDREF_ALT0
-#define DUK_TVAL_SET_BOOLEAN_UPDREF           DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0
-#define DUK_TVAL_SET_NUMBER_UPDREF            DUK_TVAL_SET_NUMBER_UPDREF_ALT0
-#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF    DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0
-#define DUK_TVAL_SET_DOUBLE_UPDREF            DUK_TVAL_SET_DOUBLE_UPDREF_ALT0
-#define DUK_TVAL_SET_NAN_UPDREF               DUK_TVAL_SET_NAN_UPDREF_ALT0
-#if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_SET_FASTINT_UPDREF           DUK_TVAL_SET_FASTINT_UPDREF_ALT0
-#define DUK_TVAL_SET_FASTINT_I32_UPDREF       DUK_TVAL_SET_FASTINT_I32_UPDREF_ALT0
-#define DUK_TVAL_SET_FASTINT_U32_UPDREF       DUK_TVAL_SET_FASTINT_U32_UPDREF_ALT0
-#else
-#define DUK_TVAL_SET_FASTINT_UPDREF           DUK_TVAL_SET_DOUBLE_CAST_UPDREF  /* XXX: fast int-to-double */
-#define DUK_TVAL_SET_FASTINT_I32_UPDREF       DUK_TVAL_SET_DOUBLE_CAST_UPDREF
-#define DUK_TVAL_SET_FASTINT_U32_UPDREF       DUK_TVAL_SET_DOUBLE_CAST_UPDREF
-#endif  /* DUK_USE_FASTINT */
-#define DUK_TVAL_SET_LIGHTFUNC_UPDREF         DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0
-#define DUK_TVAL_SET_STRING_UPDREF            DUK_TVAL_SET_STRING_UPDREF_ALT0
-#define DUK_TVAL_SET_OBJECT_UPDREF            DUK_TVAL_SET_OBJECT_UPDREF_ALT0
-#define DUK_TVAL_SET_BUFFER_UPDREF            DUK_TVAL_SET_BUFFER_UPDREF_ALT0
-#define DUK_TVAL_SET_POINTER_UPDREF           DUK_TVAL_SET_POINTER_UPDREF_ALT0
-
-#if defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
-/* Optimized for speed. */
-#define DUK_TVAL_SET_TVAL_UPDREF              DUK_TVAL_SET_TVAL_UPDREF_ALT1
-#define DUK_TVAL_SET_TVAL_UPDREF_FAST         DUK_TVAL_SET_TVAL_UPDREF_ALT1
-#define DUK_TVAL_SET_TVAL_UPDREF_SLOW         DUK_TVAL_SET_TVAL_UPDREF_ALT0
-#else
-/* Optimized for size. */
-#define DUK_TVAL_SET_TVAL_UPDREF              DUK_TVAL_SET_TVAL_UPDREF_ALT0
-#define DUK_TVAL_SET_TVAL_UPDREF_FAST         DUK_TVAL_SET_TVAL_UPDREF_ALT0
-#define DUK_TVAL_SET_TVAL_UPDREF_SLOW         DUK_TVAL_SET_TVAL_UPDREF_ALT0
-#endif
-
-#else  /* DUK_USE_REFERENCE_COUNTING */
-
-#define DUK_TVAL_INCREF_FAST(thr,v)            do {} while (0) /* nop */
-#define DUK_TVAL_DECREF_FAST(thr,v)            do {} while (0) /* nop */
-#define DUK_TVAL_INCREF_SLOW(thr,v)            do {} while (0) /* nop */
-#define DUK_TVAL_DECREF_SLOW(thr,v)            do {} while (0) /* nop */
-#define DUK_TVAL_INCREF(thr,v)                 do {} while (0) /* nop */
-#define DUK_TVAL_DECREF(thr,v)                 do {} while (0) /* nop */
-#define DUK_HEAPHDR_INCREF_FAST(thr,h)         do {} while (0) /* nop */
-#define DUK_HEAPHDR_DECREF_FAST(thr,h)         do {} while (0) /* nop */
-#define DUK_HEAPHDR_INCREF_SLOW(thr,h)         do {} while (0) /* nop */
-#define DUK_HEAPHDR_DECREF_SLOW(thr,h)         do {} while (0) /* nop */
-#define DUK_HEAPHDR_INCREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HEAPHDR_DECREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HSTRING_INCREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HSTRING_DECREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HOBJECT_INCREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HOBJECT_DECREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HBUFFER_INCREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HBUFFER_DECREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HCOMPILEDFUNCTION_INCREF(thr,h)    do {} while (0) /* nop */
-#define DUK_HCOMPILEDFUNCTION_DECREF(thr,h)    do {} while (0) /* nop */
-#define DUK_HNATIVEFUNCTION_INCREF(thr,h)      do {} while (0) /* nop */
-#define DUK_HNATIVEFUNCTION_DECREF(thr,h)      do {} while (0) /* nop */
-#define DUK_HBUFFEROBJECT_INCREF(thr,h)        do {} while (0) /* nop */
-#define DUK_HBUFFEROBJECT_DECREF(thr,h)        do {} while (0) /* nop */
-#define DUK_HTHREAD_INCREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HTHREAD_DECREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h)    do {} while (0) /* nop */
-#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h)    do {} while (0) /* nop */
-
-#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_UNDEFINED(tv__dst); \
-		DUK_UNREF((thr)); \
-	} while (0)
-
-#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_UNUSED(tv__dst); \
-		DUK_UNREF((thr)); \
-	} while (0)
-
-#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_NULL(tv__dst); \
-		DUK_UNREF((thr)); \
-	} while (0)
-
-#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-
-#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_NUMBER_CHKFAST(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_NAN(tv__dst); \
-		DUK_UNREF((thr)); \
-	} while (0)
-#if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_SET_FASTINT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_FASTINT(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-#define DUK_TVAL_SET_FASTINT_I32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_FASTINT_I32(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-#define DUK_TVAL_SET_FASTINT_U32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_FASTINT_U32(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-#else
-#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr,tvptr_dst,newval) \
-	DUK_TVAL_SET_DOUBLE_UPDREF((thr), (tvptr_dst), (duk_double_t) (newval))
-#endif  /* DUK_USE_FASTINT */
-
-#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr,tvptr_dst,lf_v,lf_fp,lf_flags) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-
-#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_STRING(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-
-#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-
-#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-
-#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
-		DUK_TVAL_SET_POINTER(tv__dst, (newval)); \
-		DUK_UNREF((thr)); \
-	} while (0)
-
-#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr,tvptr_dst,tvptr_src) do { \
-		duk_tval *tv__dst, *tv__src; \
-		tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
-		DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
-		DUK_UNREF((thr)); \
-	} while (0)
-
-#define DUK_TVAL_SET_UNDEFINED_UPDREF         DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
-#define DUK_TVAL_SET_UNUSED_UPDREF            DUK_TVAL_SET_UNUSED_UPDREF_ALT0
-#define DUK_TVAL_SET_NULL_UPDREF              DUK_TVAL_SET_NULL_UPDREF_ALT0
-#define DUK_TVAL_SET_BOOLEAN_UPDREF           DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0
-#define DUK_TVAL_SET_NUMBER_UPDREF            DUK_TVAL_SET_NUMBER_UPDREF_ALT0
-#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF    DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0
-#define DUK_TVAL_SET_DOUBLE_UPDREF            DUK_TVAL_SET_DOUBLE_UPDREF_ALT0
-#define DUK_TVAL_SET_NAN_UPDREF               DUK_TVAL_SET_NAN_UPDREF_ALT0
-#if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_SET_FASTINT_UPDREF           DUK_TVAL_SET_FASTINT_UPDREF_ALT0
-#define DUK_TVAL_SET_FASTINT_I32_UPDREF       DUK_TVAL_SET_FASTINT_I32_UPDREF_ALT0
-#define DUK_TVAL_SET_FASTINT_U32_UPDREF       DUK_TVAL_SET_FASTINT_U32_UPDREF_ALT0
-#else
-#define DUK_TVAL_SET_FASTINT_UPDREF           DUK_TVAL_SET_DOUBLE_CAST_UPDREF  /* XXX: fast-int-to-double */
-#define DUK_TVAL_SET_FASTINT_I32_UPDREF       DUK_TVAL_SET_DOUBLE_CAST_UPDREF
-#define DUK_TVAL_SET_FASTINT_U32_UPDREF       DUK_TVAL_SET_DOUBLE_CAST_UPDREF
-#endif  /* DUK_USE_FASTINT */
-#define DUK_TVAL_SET_LIGHTFUNC_UPDREF         DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0
-#define DUK_TVAL_SET_STRING_UPDREF            DUK_TVAL_SET_STRING_UPDREF_ALT0
-#define DUK_TVAL_SET_OBJECT_UPDREF            DUK_TVAL_SET_OBJECT_UPDREF_ALT0
-#define DUK_TVAL_SET_BUFFER_UPDREF            DUK_TVAL_SET_BUFFER_UPDREF_ALT0
-#define DUK_TVAL_SET_POINTER_UPDREF           DUK_TVAL_SET_POINTER_UPDREF_ALT0
-
-#define DUK_TVAL_SET_TVAL_UPDREF              DUK_TVAL_SET_TVAL_UPDREF_ALT0
-#define DUK_TVAL_SET_TVAL_UPDREF_FAST         DUK_TVAL_SET_TVAL_UPDREF_ALT0
-#define DUK_TVAL_SET_TVAL_UPDREF_SLOW         DUK_TVAL_SET_TVAL_UPDREF_ALT0
-
-#endif  /* DUK_USE_REFERENCE_COUNTING */
-
-#endif  /* DUK_HEAPHDR_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_hnativefunction.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hnativefunction.h b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hnativefunction.h
deleted file mode 100644
index 74c48e6..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hnativefunction.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- *  Heap native function representation.
- */
-
-#ifndef DUK_HNATIVEFUNCTION_H_INCLUDED
-#define DUK_HNATIVEFUNCTION_H_INCLUDED
-
-#define DUK_HNATIVEFUNCTION_NARGS_VARARGS  ((duk_int16_t) -1)
-#define DUK_HNATIVEFUNCTION_NARGS_MAX      ((duk_int16_t) 0x7fff)
-
-struct duk_hnativefunction {
-	/* shared object part */
-	duk_hobject obj;
-
-	duk_c_function func;
-	duk_int16_t nargs;
-	duk_int16_t magic;
-
-	/* The 'magic' field allows an opaque 16-bit field to be accessed by the
-	 * Duktape/C function.  This allows, for instance, the same native function
-	 * to be used for a set of very similar functions, with the 'magic' field
-	 * providing the necessary non-argument flags / values to guide the behavior
-	 * of the native function.  The value is signed on purpose: it is easier to
-	 * convert a signed value to unsigned (simply AND with 0xffff) than vice
-	 * versa.
-	 *
-	 * Note: cannot place nargs/magic into the heaphdr flags, because
-	 * duk_hobject takes almost all flags already (and needs the spare).
-	 */
-};
-
-#endif  /* DUK_HNATIVEFUNCTION_H_INCLUDED */