nifi-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ald...@apache.org
Subject [25/52] [partial] nifi-minifi-cpp git commit: Remove libxml2, civetweb thirdparty.
Date Thu, 04 May 2017 19:06:33 GMT
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/b26ac36e/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_string.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_string.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_string.c
deleted file mode 100644
index bf43750..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_string.c
+++ /dev/null
@@ -1,1314 +0,0 @@
-/*
- *  String built-ins
- */
-
-/* XXX: There are several limitations in the current implementation for
- * strings with >= 0x80000000UL characters.  In some cases one would need
- * to be able to represent the range [-0xffffffff,0xffffffff] and so on.
- * Generally character and byte length are assumed to fit into signed 32
- * bits (< 0x80000000UL).  Places with issues are not marked explicitly
- * below in all cases, look for signed type usage (duk_int_t etc) for
- * offsets/lengths.
- */
-
-#include "duk_internal.h"
-
-/*
- *  Constructor
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_string_constructor(duk_context *ctx) {
-	/* String constructor needs to distinguish between an argument not given at all
-	 * vs. given as 'undefined'.  We're a vararg function to handle this properly.
-	 */
-
-	if (duk_get_top(ctx) == 0) {
-		duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
-	} else {
-		duk_to_string(ctx, 0);
-	}
-	DUK_ASSERT(duk_is_string(ctx, 0));
-	duk_set_top(ctx, 1);
-
-	if (duk_is_constructor_call(ctx)) {
-		duk_push_object_helper(ctx,
-		                       DUK_HOBJECT_FLAG_EXTENSIBLE |
-		                       DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ |
-		                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_STRING),
-		                       DUK_BIDX_STRING_PROTOTYPE);
-
-		/* String object internal value is immutable */
-		duk_dup(ctx, 0);
-		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
-	}
-	/* Note: unbalanced stack on purpose */
-
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_string_constructor_from_char_code(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_bufwriter_ctx bw_alloc;
-	duk_bufwriter_ctx *bw;
-	duk_idx_t i, n;
-	duk_ucodepoint_t cp;
-
-	/* XXX: It would be nice to build the string directly but ToUint16()
-	 * coercion is needed so a generic helper would not be very
-	 * helpful (perhaps coerce the value stack first here and then
-	 * build a string from a duk_tval number sequence in one go?).
-	 */
-
-	n = duk_get_top(ctx);
-
-	bw = &bw_alloc;
-	DUK_BW_INIT_PUSHBUF(thr, bw, n);  /* initial estimate for ASCII only codepoints */
-
-	for (i = 0; i < n; i++) {
-		/* XXX: could improve bufwriter handling to write multiple codepoints
-		 * with one ensure call but the relative benefit would be quite small.
-		 */
-
-#if defined(DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT)
-		/* ToUint16() coercion is mandatory in the E5.1 specification, but
-		 * this non-compliant behavior makes more sense because we support
-		 * non-BMP codepoints.  Don't use CESU-8 because that'd create
-		 * surrogate pairs.
-		 */
-
-		cp = (duk_ucodepoint_t) duk_to_uint32(ctx, i);
-		DUK_BW_WRITE_ENSURE_XUTF8(thr, bw, cp);
-#else
-		cp = (duk_ucodepoint_t) duk_to_uint16(ctx, i);
-		DUK_BW_WRITE_ENSURE_CESU8(thr, bw, cp);
-#endif
-	}
-
-	DUK_BW_COMPACT(thr, bw);
-	duk_to_string(ctx, -1);
-	return 1;
-}
-
-/*
- *  toString(), valueOf()
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_to_string(duk_context *ctx) {
-	duk_tval *tv;
-
-	duk_push_this(ctx);
-	tv = duk_require_tval(ctx, -1);
-	DUK_ASSERT(tv != NULL);
-
-	if (DUK_TVAL_IS_STRING(tv)) {
-		/* return as is */
-		return 1;
-	} else if (DUK_TVAL_IS_OBJECT(tv)) {
-		duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
-		DUK_ASSERT(h != NULL);
-
-		/* Must be a "string object", i.e. class "String" */
-		if (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_STRING) {
-			goto type_error;
-		}
-
-		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
-		DUK_ASSERT(duk_is_string(ctx, -1));
-
-		return 1;
-	} else {
-		goto type_error;
-	}
-
-	/* never here, but fall through */
-
- type_error:
-	return DUK_RET_TYPE_ERROR;
-}
-
-/*
- *  Character and charcode access
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_char_at(duk_context *ctx) {
-	duk_int_t pos;
-
-	/* XXX: faster implementation */
-
-	(void) duk_push_this_coercible_to_string(ctx);
-	pos = duk_to_int(ctx, 0);
-	duk_substring(ctx, -1, pos, pos + 1);
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_char_code_at(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_int_t pos;
-	duk_hstring *h;
-	duk_bool_t clamped;
-
-	/* XXX: faster implementation */
-
-	DUK_DDD(DUK_DDDPRINT("arg=%!T", (duk_tval *) duk_get_tval(ctx, 0)));
-
-	h = duk_push_this_coercible_to_string(ctx);
-	DUK_ASSERT(h != NULL);
-
-	pos = duk_to_int_clamped_raw(ctx,
-	                             0 /*index*/,
-	                             0 /*min(incl)*/,
-	                             DUK_HSTRING_GET_CHARLEN(h) - 1 /*max(incl)*/,
-	                             &clamped /*out_clamped*/);
-	if (clamped) {
-		duk_push_number(ctx, DUK_DOUBLE_NAN);
-		return 1;
-	}
-
-	duk_push_u32(ctx, (duk_uint32_t) duk_hstring_char_code_at_raw(thr, h, pos));
-	return 1;
-}
-
-/*
- *  substring(), substr(), slice()
- */
-
-/* XXX: any chance of merging these three similar but still slightly
- * different algorithms so that footprint would be reduced?
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substring(duk_context *ctx) {
-	duk_hstring *h;
-	duk_int_t start_pos, end_pos;
-	duk_int_t len;
-
-	h = duk_push_this_coercible_to_string(ctx);
-	DUK_ASSERT(h != NULL);
-	len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h);
-
-	/* [ start end str ] */
-
-	start_pos = duk_to_int_clamped(ctx, 0, 0, len);
-	if (duk_is_undefined(ctx, 1)) {
-		end_pos = len;
-	} else {
-		end_pos = duk_to_int_clamped(ctx, 1, 0, len);
-	}
-	DUK_ASSERT(start_pos >= 0 && start_pos <= len);
-	DUK_ASSERT(end_pos >= 0 && end_pos <= len);
-
-	if (start_pos > end_pos) {
-		duk_int_t tmp = start_pos;
-		start_pos = end_pos;
-		end_pos = tmp;
-	}
-
-	DUK_ASSERT(end_pos >= start_pos);
-
-	duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos);
-	return 1;
-}
-
-#ifdef DUK_USE_SECTION_B
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx) {
-	duk_hstring *h;
-	duk_int_t start_pos, end_pos;
-	duk_int_t len;
-
-	/* Unlike non-obsolete String calls, substr() algorithm in E5.1
-	 * specification will happily coerce undefined and null to strings
-	 * ("undefined" and "null").
-	 */
-	duk_push_this(ctx);
-	h = duk_to_hstring(ctx, -1);
-	DUK_ASSERT(h != NULL);
-	len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h);
-
-	/* [ start length str ] */
-
-	/* The implementation for computing of start_pos and end_pos differs
-	 * from the standard algorithm, but is intended to result in the exactly
-	 * same behavior.  This is not always obvious.
-	 */
-
-	/* combines steps 2 and 5; -len ensures max() not needed for step 5 */
-	start_pos = duk_to_int_clamped(ctx, 0, -len, len);
-	if (start_pos < 0) {
-		start_pos = len + start_pos;
-	}
-	DUK_ASSERT(start_pos >= 0 && start_pos <= len);
-
-	/* combines steps 3, 6; step 7 is not needed */
-	if (duk_is_undefined(ctx, 1)) {
-		end_pos = len;
-	} else {
-		DUK_ASSERT(start_pos <= len);
-		end_pos = start_pos + duk_to_int_clamped(ctx, 1, 0, len - start_pos);
-	}
-	DUK_ASSERT(start_pos >= 0 && start_pos <= len);
-	DUK_ASSERT(end_pos >= 0 && end_pos <= len);
-	DUK_ASSERT(end_pos >= start_pos);
-
-	duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos);
-	return 1;
-}
-#else  /* DUK_USE_SECTION_B */
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNSUPPORTED_ERROR;
-}
-#endif  /* DUK_USE_SECTION_B */
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_slice(duk_context *ctx) {
-	duk_hstring *h;
-	duk_int_t start_pos, end_pos;
-	duk_int_t len;
-
-	h = duk_push_this_coercible_to_string(ctx);
-	DUK_ASSERT(h != NULL);
-	len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h);
-
-	/* [ start end str ] */
-
-	start_pos = duk_to_int_clamped(ctx, 0, -len, len);
-	if (start_pos < 0) {
-		start_pos = len + start_pos;
-	}
-	if (duk_is_undefined(ctx, 1)) {
-		end_pos = len;
-	} else {
-		end_pos = duk_to_int_clamped(ctx, 1, -len, len);
-		if (end_pos < 0) {
-			end_pos = len + end_pos;
-		}
-	}
-	DUK_ASSERT(start_pos >= 0 && start_pos <= len);
-	DUK_ASSERT(end_pos >= 0 && end_pos <= len);
-
-	if (end_pos < start_pos) {
-		end_pos = start_pos;
-	}
-
-	DUK_ASSERT(end_pos >= start_pos);
-
-	duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos);
-	return 1;
-}
-
-/*
- *  Case conversion
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_caseconv_shared(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_small_int_t uppercase = duk_get_current_magic(ctx);
-
-	(void) duk_push_this_coercible_to_string(ctx);
-	duk_unicode_case_convert_string(thr, (duk_bool_t) uppercase);
-	return 1;
-}
-
-/*
- *  indexOf() and lastIndexOf()
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_indexof_shared(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hstring *h_this;
-	duk_hstring *h_search;
-	duk_int_t clen_this;
-	duk_int_t cpos;
-	duk_int_t bpos;
-	const duk_uint8_t *p_start, *p_end, *p;
-	const duk_uint8_t *q_start;
-	duk_int_t q_blen;
-	duk_uint8_t firstbyte;
-	duk_uint8_t t;
-	duk_small_int_t is_lastindexof = duk_get_current_magic(ctx);  /* 0=indexOf, 1=lastIndexOf */
-
-	h_this = duk_push_this_coercible_to_string(ctx);
-	DUK_ASSERT(h_this != NULL);
-	clen_this = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h_this);
-
-	h_search = duk_to_hstring(ctx, 0);
-	DUK_ASSERT(h_search != NULL);
-	q_start = DUK_HSTRING_GET_DATA(h_search);
-	q_blen = (duk_int_t) DUK_HSTRING_GET_BYTELEN(h_search);
-
-	duk_to_number(ctx, 1);
-	if (duk_is_nan(ctx, 1) && is_lastindexof) {
-		/* indexOf: NaN should cause pos to be zero.
-		 * lastIndexOf: NaN should cause pos to be +Infinity
-		 * (and later be clamped to len).
-		 */
-		cpos = clen_this;
-	} else {
-		cpos = duk_to_int_clamped(ctx, 1, 0, clen_this);
-	}
-
-	/* Empty searchstring always matches; cpos must be clamped here.
-	 * (If q_blen were < 0 due to clamped coercion, it would also be
-	 * caught here.)
-	 */
-	if (q_blen <= 0) {
-		duk_push_int(ctx, cpos);
-		return 1;
-	}
-	DUK_ASSERT(q_blen > 0);
-
-	bpos = (duk_int_t) duk_heap_strcache_offset_char2byte(thr, h_this, (duk_uint32_t) cpos);
-
-	p_start = DUK_HSTRING_GET_DATA(h_this);
-	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_this);
-	p = p_start + bpos;
-
-	/* This loop is optimized for size.  For speed, there should be
-	 * two separate loops, and we should ensure that memcmp() can be
-	 * used without an extra "will searchstring fit" check.  Doing
-	 * the preconditioning for 'p' and 'p_end' is easy but cpos
-	 * must be updated if 'p' is wound back (backward scanning).
-	 */
-
-	firstbyte = q_start[0];  /* leading byte of match string */
-	while (p <= p_end && p >= p_start) {
-		t = *p;
-
-		/* For Ecmascript strings, this check can only match for
-		 * initial UTF-8 bytes (not continuation bytes).  For other
-		 * strings all bets are off.
-		 */
-
-		if ((t == firstbyte) && ((duk_size_t) (p_end - p) >= (duk_size_t) q_blen)) {
-			DUK_ASSERT(q_blen > 0);  /* no issues with memcmp() zero size, even if broken */
-			if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) {
-				duk_push_int(ctx, cpos);
-				return 1;
-			}
-		}
-
-		/* track cpos while scanning */
-		if (is_lastindexof) {
-			/* when going backwards, we decrement cpos 'early';
-			 * 'p' may point to a continuation byte of the char
-			 * at offset 'cpos', but that's OK because we'll
-			 * backtrack all the way to the initial byte.
-			 */
-			if ((t & 0xc0) != 0x80) {
-				cpos--;
-			}
-			p--;
-		} else {
-			if ((t & 0xc0) != 0x80) {
-				cpos++;
-			}
-			p++;
-		}
-	}
-
-	/* Not found.  Empty string case is handled specially above. */
-	duk_push_int(ctx, -1);
-	return 1;
-}
-
-/*
- *  replace()
- */
-
-/* XXX: the current implementation works but is quite clunky; it compiles
- * to almost 1,4kB of x86 code so it needs to be simplified (better approach,
- * shared helpers, etc).  Some ideas for refactoring:
- *
- * - a primitive to convert a string into a regexp matcher (reduces matching
- *   code at the cost of making matching much slower)
- * - use replace() as a basic helper for match() and split(), which are both
- *   much simpler
- * - API call to get_prop and to_boolean
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hstring *h_input;
-	duk_hstring *h_match;
-	duk_hstring *h_search;
-	duk_hobject *h_re;
-	duk_bufwriter_ctx bw_alloc;
-	duk_bufwriter_ctx *bw;
-#ifdef DUK_USE_REGEXP_SUPPORT
-	duk_bool_t is_regexp;
-	duk_bool_t is_global;
-#endif
-	duk_bool_t is_repl_func;
-	duk_uint32_t match_start_coff, match_start_boff;
-#ifdef DUK_USE_REGEXP_SUPPORT
-	duk_int_t match_caps;
-#endif
-	duk_uint32_t prev_match_end_boff;
-	const duk_uint8_t *r_start, *r_end, *r;   /* repl string scan */
-	duk_size_t tmp_sz;
-
-	DUK_ASSERT_TOP(ctx, 2);
-	h_input = duk_push_this_coercible_to_string(ctx);
-	DUK_ASSERT(h_input != NULL);
-
-	bw = &bw_alloc;
-	DUK_BW_INIT_PUSHBUF(thr, bw, DUK_HSTRING_GET_BYTELEN(h_input));  /* input size is good output starting point */
-
-	DUK_ASSERT_TOP(ctx, 4);
-
-	/* stack[0] = search value
-	 * stack[1] = replace value
-	 * stack[2] = input string
-	 * stack[3] = result buffer
-	 */
-
-	h_re = duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_REGEXP);
-	if (h_re) {
-#ifdef DUK_USE_REGEXP_SUPPORT
-		is_regexp = 1;
-		is_global = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
-
-		if (is_global) {
-			/* start match from beginning */
-			duk_push_int(ctx, 0);
-			duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-		}
-#else  /* DUK_USE_REGEXP_SUPPORT */
-		return DUK_RET_UNSUPPORTED_ERROR;
-#endif  /* DUK_USE_REGEXP_SUPPORT */
-	} else {
-		duk_to_string(ctx, 0);
-#ifdef DUK_USE_REGEXP_SUPPORT
-		is_regexp = 0;
-		is_global = 0;
-#endif
-	}
-
-	if (duk_is_function(ctx, 1)) {
-		is_repl_func = 1;
-		r_start = NULL;
-		r_end = NULL;
-	} else {
-		duk_hstring *h_repl;
-
-		is_repl_func = 0;
-		h_repl = duk_to_hstring(ctx, 1);
-		DUK_ASSERT(h_repl != NULL);
-		r_start = DUK_HSTRING_GET_DATA(h_repl);
-		r_end = r_start + DUK_HSTRING_GET_BYTELEN(h_repl);
-	}
-
-	prev_match_end_boff = 0;
-
-	for (;;) {
-		/*
-		 *  If matching with a regexp:
-		 *    - non-global RegExp: lastIndex not touched on a match, zeroed
-		 *      on a non-match
-		 *    - global RegExp: on match, lastIndex will be updated by regexp
-		 *      executor to point to next char after the matching part (so that
-		 *      characters in the matching part are not matched again)
-		 *
-		 *  If matching with a string:
-		 *    - always non-global match, find first occurrence
-		 *
-		 *  We need:
-		 *    - The character offset of start-of-match for the replacer function
-		 *    - The byte offsets for start-of-match and end-of-match to implement
-		 *      the replacement values $&, $`, and $', and to copy non-matching
-		 *      input string portions (including header and trailer) verbatim.
-		 *
-		 *  NOTE: the E5.1 specification is a bit vague how the RegExp should
-		 *  behave in the replacement process; e.g. is matching done first for
-		 *  all matches (in the global RegExp case) before any replacer calls
-		 *  are made?  See: test-bi-string-proto-replace.js for discussion.
-		 */
-
-		DUK_ASSERT_TOP(ctx, 4);
-
-#ifdef DUK_USE_REGEXP_SUPPORT
-		if (is_regexp) {
-			duk_dup(ctx, 0);
-			duk_dup(ctx, 2);
-			duk_regexp_match(thr);  /* [ ... regexp input ] -> [ res_obj ] */
-			if (!duk_is_object(ctx, -1)) {
-				duk_pop(ctx);
-				break;
-			}
-
-			duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
-			DUK_ASSERT(duk_is_number(ctx, -1));
-			match_start_coff = duk_get_int(ctx, -1);
-			duk_pop(ctx);
-
-			duk_get_prop_index(ctx, -1, 0);
-			DUK_ASSERT(duk_is_string(ctx, -1));
-			h_match = duk_get_hstring(ctx, -1);
-			DUK_ASSERT(h_match != NULL);
-			duk_pop(ctx);  /* h_match is borrowed, remains reachable through match_obj */
-
-			if (DUK_HSTRING_GET_BYTELEN(h_match) == 0) {
-				/* This should be equivalent to match() algorithm step 8.f.iii.2:
-				 * detect an empty match and allow it, but don't allow it twice.
-				 */
-				duk_uint32_t last_index;
-
-				duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-				last_index = (duk_uint32_t) duk_get_uint(ctx, -1);
-				DUK_DDD(DUK_DDDPRINT("empty match, bump lastIndex: %ld -> %ld",
-				                     (long) last_index, (long) (last_index + 1)));
-				duk_pop(ctx);
-				duk_push_int(ctx, last_index + 1);
-				duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-			}
-
-			DUK_ASSERT(duk_get_length(ctx, -1) <= DUK_INT_MAX);  /* string limits */
-			match_caps = (duk_int_t) duk_get_length(ctx, -1);
-		} else {
-#else  /* DUK_USE_REGEXP_SUPPORT */
-		{  /* unconditionally */
-#endif  /* DUK_USE_REGEXP_SUPPORT */
-			const duk_uint8_t *p_start, *p_end, *p;   /* input string scan */
-			const duk_uint8_t *q_start;               /* match string */
-			duk_size_t q_blen;
-
-#ifdef DUK_USE_REGEXP_SUPPORT
-			DUK_ASSERT(!is_global);  /* single match always */
-#endif
-
-			p_start = DUK_HSTRING_GET_DATA(h_input);
-			p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
-			p = p_start;
-
-			h_search = duk_get_hstring(ctx, 0);
-			DUK_ASSERT(h_search != NULL);
-			q_start = DUK_HSTRING_GET_DATA(h_search);
-			q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_search);
-
-			p_end -= q_blen;  /* ensure full memcmp() fits in while */
-
-			match_start_coff = 0;
-
-			while (p <= p_end) {
-				DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input));
-				if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) {
-					duk_dup(ctx, 0);
-					h_match = duk_get_hstring(ctx, -1);
-					DUK_ASSERT(h_match != NULL);
-#ifdef DUK_USE_REGEXP_SUPPORT
-					match_caps = 0;
-#endif
-					goto found;
-				}
-
-				/* track utf-8 non-continuation bytes */
-				if ((p[0] & 0xc0) != 0x80) {
-					match_start_coff++;
-				}
-				p++;
-			}
-
-			/* not found */
-			break;
-		}
-	 found:
-
-		/* stack[0] = search value
-		 * stack[1] = replace value
-		 * stack[2] = input string
-		 * stack[3] = result buffer
-		 * stack[4] = regexp match OR match string
-		 */
-
-		match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff);
-
-		tmp_sz = (duk_size_t) (match_start_boff - prev_match_end_boff);
-		DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, tmp_sz);
-
-		prev_match_end_boff = match_start_boff + DUK_HSTRING_GET_BYTELEN(h_match);
-
-		if (is_repl_func) {
-			duk_idx_t idx_args;
-			duk_hstring *h_repl;
-
-			/* regexp res_obj is at index 4 */
-
-			duk_dup(ctx, 1);
-			idx_args = duk_get_top(ctx);
-
-#ifdef DUK_USE_REGEXP_SUPPORT
-			if (is_regexp) {
-				duk_int_t idx;
-				duk_require_stack(ctx, match_caps + 2);
-				for (idx = 0; idx < match_caps; idx++) {
-					/* match followed by capture(s) */
-					duk_get_prop_index(ctx, 4, idx);
-				}
-			} else {
-#else  /* DUK_USE_REGEXP_SUPPORT */
-			{  /* unconditionally */
-#endif  /* DUK_USE_REGEXP_SUPPORT */
-				/* match == search string, by definition */
-				duk_dup(ctx, 0);
-			}
-			duk_push_int(ctx, match_start_coff);
-			duk_dup(ctx, 2);
-
-			/* [ ... replacer match [captures] match_char_offset input ] */
-
-			duk_call(ctx, duk_get_top(ctx) - idx_args);
-			h_repl = duk_to_hstring(ctx, -1);  /* -> [ ... repl_value ] */
-			DUK_ASSERT(h_repl != NULL);
-
-			DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_repl);
-
-			duk_pop(ctx);  /* repl_value */
-		} else {
-			r = r_start;
-
-			while (r < r_end) {
-				duk_int_t ch1;
-				duk_int_t ch2;
-#ifdef DUK_USE_REGEXP_SUPPORT
-				duk_int_t ch3;
-#endif
-				duk_size_t left;
-
-				ch1 = *r++;
-				if (ch1 != DUK_ASC_DOLLAR) {
-					goto repl_write;
-				}
-				left = r_end - r;
-
-				if (left <= 0) {
-					goto repl_write;
-				}
-
-				ch2 = r[0];
-				switch ((int) ch2) {
-				case DUK_ASC_DOLLAR: {
-					ch1 = (1 << 8) + DUK_ASC_DOLLAR;
-					goto repl_write;
-				}
-				case DUK_ASC_AMP: {
-					DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_match);
-					r++;
-					continue;
-				}
-				case DUK_ASC_GRAVE: {
-					tmp_sz = (duk_size_t) match_start_boff;
-					DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input), tmp_sz);
-					r++;
-					continue;
-				}
-				case DUK_ASC_SINGLEQUOTE: {
-					duk_uint32_t match_end_boff;
-
-					/* Use match charlen instead of bytelen, just in case the input and
-					 * match codepoint encodings would have different lengths.
-					 */
-					match_end_boff = duk_heap_strcache_offset_char2byte(thr,
-					                                                    h_input,
-					                                                    match_start_coff + DUK_HSTRING_GET_CHARLEN(h_match));
-
-					tmp_sz = (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - match_end_boff);
-					DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + match_end_boff, tmp_sz);
-					r++;
-					continue;
-				}
-				default: {
-#ifdef DUK_USE_REGEXP_SUPPORT
-					duk_int_t capnum, captmp, capadv;
-					/* XXX: optional check, match_caps is zero if no regexp,
-					 * so dollar will be interpreted literally anyway.
-					 */
-
-					if (!is_regexp) {
-						goto repl_write;
-					}
-
-					if (!(ch2 >= DUK_ASC_0 && ch2 <= DUK_ASC_9)) {
-						goto repl_write;
-					}
-					capnum = ch2 - DUK_ASC_0;
-					capadv = 1;
-
-					if (left >= 2) {
-						ch3 = r[1];
-						if (ch3 >= DUK_ASC_0 && ch3 <= DUK_ASC_9) {
-							captmp = capnum * 10 + (ch3 - DUK_ASC_0);
-							if (captmp < match_caps) {
-								capnum = captmp;
-								capadv = 2;
-							}
-						}
-					}
-
-					if (capnum > 0 && capnum < match_caps) {
-						DUK_ASSERT(is_regexp != 0);  /* match_caps == 0 without regexps */
-
-						/* regexp res_obj is at offset 4 */
-						duk_get_prop_index(ctx, 4, (duk_uarridx_t) capnum);
-						if (duk_is_string(ctx, -1)) {
-							duk_hstring *h_tmp_str;
-
-							h_tmp_str = duk_get_hstring(ctx, -1);
-							DUK_ASSERT(h_tmp_str != NULL);
-
-							DUK_BW_WRITE_ENSURE_HSTRING(thr, bw, h_tmp_str);
-						} else {
-							/* undefined -> skip (replaced with empty) */
-						}
-						duk_pop(ctx);
-						r += capadv;
-						continue;
-					} else {
-						goto repl_write;
-					}
-#else  /* DUK_USE_REGEXP_SUPPORT */
-					goto repl_write;  /* unconditionally */
-#endif  /* DUK_USE_REGEXP_SUPPORT */
-				}  /* default case */
-				}  /* switch (ch2) */
-
-			 repl_write:
-				/* ch1 = (r_increment << 8) + byte */
-
-				DUK_BW_WRITE_ENSURE_U8(thr, bw, (duk_uint8_t) (ch1 & 0xff));
-				r += ch1 >> 8;
-			}  /* while repl */
-		}  /* if (is_repl_func) */
-
-		duk_pop(ctx);  /* pop regexp res_obj or match string */
-
-#ifdef DUK_USE_REGEXP_SUPPORT
-		if (!is_global) {
-#else
-		{  /* unconditionally; is_global==0 */
-#endif
-			break;
-		}
-	}
-
-	/* trailer */
-	tmp_sz = (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - prev_match_end_boff);
-	DUK_BW_WRITE_ENSURE_BYTES(thr, bw, DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff, tmp_sz);
-
-	DUK_ASSERT_TOP(ctx, 4);
-	DUK_BW_COMPACT(thr, bw);
-	duk_to_string(ctx, -1);
-	return 1;
-}
-
-/*
- *  split()
- */
-
-/* XXX: very messy now, but works; clean up, remove unused variables (nomimally
- * used so compiler doesn't complain).
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_split(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hstring *h_input;
-	duk_hstring *h_sep;
-	duk_uint32_t limit;
-	duk_uint32_t arr_idx;
-#ifdef DUK_USE_REGEXP_SUPPORT
-	duk_bool_t is_regexp;
-#endif
-	duk_bool_t matched;  /* set to 1 if any match exists (needed for empty input special case) */
-	duk_uint32_t prev_match_end_coff, prev_match_end_boff;
-	duk_uint32_t match_start_boff, match_start_coff;
-	duk_uint32_t match_end_boff, match_end_coff;
-
-	DUK_UNREF(thr);
-
-	h_input = duk_push_this_coercible_to_string(ctx);
-	DUK_ASSERT(h_input != NULL);
-
-	duk_push_array(ctx);
-
-	if (duk_is_undefined(ctx, 1)) {
-		limit = 0xffffffffUL;
-	} else {
-		limit = duk_to_uint32(ctx, 1);
-	}
-
-	if (limit == 0) {
-		return 1;
-	}
-
-	/* If the separator is a RegExp, make a "clone" of it.  The specification
-	 * algorithm calls [[Match]] directly for specific indices; we emulate this
-	 * by tweaking lastIndex and using a "force global" variant of duk_regexp_match()
-	 * which will use global-style matching even when the RegExp itself is non-global.
-	 */
-
-	if (duk_is_undefined(ctx, 0)) {
-		/* The spec algorithm first does "R = ToString(separator)" before checking
-		 * whether separator is undefined.  Since this is side effect free, we can
-		 * skip the ToString() here.
-		 */
-		duk_dup(ctx, 2);
-		duk_put_prop_index(ctx, 3, 0);
-		return 1;
-	} else if (duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_REGEXP) != NULL) {
-#ifdef DUK_USE_REGEXP_SUPPORT
-		duk_push_hobject_bidx(ctx, DUK_BIDX_REGEXP_CONSTRUCTOR);
-		duk_dup(ctx, 0);
-		duk_new(ctx, 1);  /* [ ... RegExp val ] -> [ ... res ] */
-		duk_replace(ctx, 0);
-		/* lastIndex is initialized to zero by new RegExp() */
-		is_regexp = 1;
-#else
-		return DUK_RET_UNSUPPORTED_ERROR;
-#endif
-	} else {
-		duk_to_string(ctx, 0);
-#ifdef DUK_USE_REGEXP_SUPPORT
-		is_regexp = 0;
-#endif
-	}
-
-	/* stack[0] = separator (string or regexp)
-	 * stack[1] = limit
-	 * stack[2] = input string
-	 * stack[3] = result array
-	 */
-
-	prev_match_end_boff = 0;
-	prev_match_end_coff = 0;
-	arr_idx = 0;
-	matched = 0;
-
-	for (;;) {
-		/*
-		 *  The specification uses RegExp [[Match]] to attempt match at specific
-		 *  offsets.  We don't have such a primitive, so we use an actual RegExp
-		 *  and tweak lastIndex.  Since the RegExp may be non-global, we use a
-		 *  special variant which forces global-like behavior for matching.
-		 */
-
-		DUK_ASSERT_TOP(ctx, 4);
-
-#ifdef DUK_USE_REGEXP_SUPPORT
-		if (is_regexp) {
-			duk_dup(ctx, 0);
-			duk_dup(ctx, 2);
-			duk_regexp_match_force_global(thr);  /* [ ... regexp input ] -> [ res_obj ] */
-			if (!duk_is_object(ctx, -1)) {
-				duk_pop(ctx);
-				break;
-			}
-			matched = 1;
-
-			duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
-			DUK_ASSERT(duk_is_number(ctx, -1));
-			match_start_coff = duk_get_int(ctx, -1);
-			match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff);
-			duk_pop(ctx);
-
-			if (match_start_coff == DUK_HSTRING_GET_CHARLEN(h_input)) {
-				/* don't allow an empty match at the end of the string */
-				duk_pop(ctx);
-				break;
-			}
-
-			duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-			DUK_ASSERT(duk_is_number(ctx, -1));
-			match_end_coff = duk_get_int(ctx, -1);
-			match_end_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_end_coff);
-			duk_pop(ctx);
-
-			/* empty match -> bump and continue */
-			if (prev_match_end_boff == match_end_boff) {
-				duk_push_int(ctx, match_end_coff + 1);
-				duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-				duk_pop(ctx);
-				continue;
-			}
-		} else {
-#else  /* DUK_USE_REGEXP_SUPPORT */
-		{  /* unconditionally */
-#endif  /* DUK_USE_REGEXP_SUPPORT */
-			const duk_uint8_t *p_start, *p_end, *p;   /* input string scan */
-			const duk_uint8_t *q_start;               /* match string */
-			duk_size_t q_blen, q_clen;
-
-			p_start = DUK_HSTRING_GET_DATA(h_input);
-			p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
-			p = p_start + prev_match_end_boff;
-
-			h_sep = duk_get_hstring(ctx, 0);
-			DUK_ASSERT(h_sep != NULL);
-			q_start = DUK_HSTRING_GET_DATA(h_sep);
-			q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sep);
-			q_clen = (duk_size_t) DUK_HSTRING_GET_CHARLEN(h_sep);
-
-			p_end -= q_blen;  /* ensure full memcmp() fits in while */
-
-			match_start_coff = prev_match_end_coff;
-
-			if (q_blen == 0) {
-				/* Handle empty separator case: it will always match, and always
-				 * triggers the check in step 13.c.iii initially.  Note that we
-				 * must skip to either end of string or start of first codepoint,
-				 * skipping over any continuation bytes!
-				 *
-				 * Don't allow an empty string to match at the end of the input.
-				 */
-
-				matched = 1;  /* empty separator can always match */
-
-				match_start_coff++;
-				p++;
-				while (p < p_end) {
-					if ((p[0] & 0xc0) != 0x80) {
-						goto found;
-					}
-					p++;
-				}
-				goto not_found;
-			}
-
-			DUK_ASSERT(q_blen > 0 && q_clen > 0);
-			while (p <= p_end) {
-				DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input));
-				DUK_ASSERT(q_blen > 0);  /* no issues with empty memcmp() */
-				if (DUK_MEMCMP((const void *) p, (const void *) q_start, (size_t) q_blen) == 0) {
-					/* never an empty match, so step 13.c.iii can't be triggered */
-					goto found;
-				}
-
-				/* track utf-8 non-continuation bytes */
-				if ((p[0] & 0xc0) != 0x80) {
-					match_start_coff++;
-				}
-				p++;
-			}
-
-		 not_found:
-			/* not found */
-			break;
-
-		 found:
-			matched = 1;
-			match_start_boff = (duk_uint32_t) (p - p_start);
-			match_end_coff = (duk_uint32_t) (match_start_coff + q_clen);  /* constrained by string length */
-			match_end_boff = (duk_uint32_t) (match_start_boff + q_blen);  /* ditto */
-
-			/* empty match (may happen with empty separator) -> bump and continue */
-			if (prev_match_end_boff == match_end_boff) {
-				prev_match_end_boff++;
-				prev_match_end_coff++;
-				continue;
-			}
-		}  /* if (is_regexp) */
-
-		/* stack[0] = separator (string or regexp)
-		 * stack[1] = limit
-		 * stack[2] = input string
-		 * stack[3] = result array
-		 * stack[4] = regexp res_obj (if is_regexp)
-		 */
-
-		DUK_DDD(DUK_DDDPRINT("split; match_start b=%ld,c=%ld, match_end b=%ld,c=%ld, prev_end b=%ld,c=%ld",
-		                     (long) match_start_boff, (long) match_start_coff,
-		                     (long) match_end_boff, (long) match_end_coff,
-		                     (long) prev_match_end_boff, (long) prev_match_end_coff));
-
-		duk_push_lstring(ctx,
-		                 (const char *) (DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff),
-		                 (duk_size_t) (match_start_boff - prev_match_end_boff));
-		duk_put_prop_index(ctx, 3, arr_idx);
-		arr_idx++;
-		if (arr_idx >= limit) {
-			goto hit_limit;
-		}
-
-#ifdef DUK_USE_REGEXP_SUPPORT
-		if (is_regexp) {
-			duk_size_t i, len;
-
-			len = duk_get_length(ctx, 4);
-			for (i = 1; i < len; i++) {
-				DUK_ASSERT(i <= DUK_UARRIDX_MAX);  /* cannot have >4G captures */
-				duk_get_prop_index(ctx, 4, (duk_uarridx_t) i);
-				duk_put_prop_index(ctx, 3, arr_idx);
-				arr_idx++;
-				if (arr_idx >= limit) {
-					goto hit_limit;
-				}
-			}
-
-			duk_pop(ctx);
-			/* lastIndex already set up for next match */
-		} else {
-#else  /* DUK_USE_REGEXP_SUPPORT */
-		{  /* unconditionally */
-#endif  /* DUK_USE_REGEXP_SUPPORT */
-			/* no action */
-		}
-
-		prev_match_end_boff = match_end_boff;
-		prev_match_end_coff = match_end_coff;
-		continue;
-	}  /* for */
-
-	/* Combined step 11 (empty string special case) and 14-15. */
-
-	DUK_DDD(DUK_DDDPRINT("split trailer; prev_end b=%ld,c=%ld",
-	                     (long) prev_match_end_boff, (long) prev_match_end_coff));
-
-	if (DUK_HSTRING_GET_CHARLEN(h_input) > 0 || !matched) {
-		/* Add trailer if:
-		 *   a) non-empty input
-		 *   b) empty input and no (zero size) match found (step 11)
-		 */
-
-		duk_push_lstring(ctx,
-		                 (const char *) DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff,
-		                 (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - prev_match_end_boff));
-		duk_put_prop_index(ctx, 3, arr_idx);
-		/* No arr_idx update or limit check */
-	}
-
-	return 1;
-
- hit_limit:
-#ifdef DUK_USE_REGEXP_SUPPORT
-	if (is_regexp) {
-		duk_pop(ctx);
-	}
-#endif
-
-	return 1;
-}
-
-/*
- *  Various
- */
-
-#ifdef DUK_USE_REGEXP_SUPPORT
-DUK_LOCAL void duk__to_regexp_helper(duk_context *ctx, duk_idx_t index, duk_bool_t force_new) {
-	duk_hobject *h;
-
-	/* Shared helper for match() steps 3-4, search() steps 3-4. */
-
-	DUK_ASSERT(index >= 0);
-
-	if (force_new) {
-		goto do_new;
-	}
-
-	h = duk_get_hobject_with_class(ctx, index, DUK_HOBJECT_CLASS_REGEXP);
-	if (!h) {
-		goto do_new;
-	}
-	return;
-
- do_new:
-	duk_push_hobject_bidx(ctx, DUK_BIDX_REGEXP_CONSTRUCTOR);
-	duk_dup(ctx, index);
-	duk_new(ctx, 1);  /* [ ... RegExp val ] -> [ ... res ] */
-	duk_replace(ctx, index);
-}
-#endif  /* DUK_USE_REGEXP_SUPPORT */
-
-#ifdef DUK_USE_REGEXP_SUPPORT
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-
-	/* Easiest way to implement the search required by the specification
-	 * is to do a RegExp test() with lastIndex forced to zero.  To avoid
-	 * side effects on the argument, "clone" the RegExp if a RegExp was
-	 * given as input.
-	 *
-	 * The global flag of the RegExp should be ignored; setting lastIndex
-	 * to zero (which happens when "cloning" the RegExp) should have an
-	 * equivalent effect.
-	 */
-
-	DUK_ASSERT_TOP(ctx, 1);
-	(void) duk_push_this_coercible_to_string(ctx);  /* at index 1 */
-	duk__to_regexp_helper(ctx, 0 /*index*/, 1 /*force_new*/);
-
-	/* stack[0] = regexp
-	 * stack[1] = string
-	 */
-
-	/* Avoid using RegExp.prototype methods, as they're writable and
-	 * configurable and may have been changed.
-	 */
-
-	duk_dup(ctx, 0);
-	duk_dup(ctx, 1);  /* [ ... re_obj input ] */
-	duk_regexp_match(thr);  /* -> [ ... res_obj ] */
-
-	if (!duk_is_object(ctx, -1)) {
-		duk_push_int(ctx, -1);
-		return 1;
-	}
-
-	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
-	DUK_ASSERT(duk_is_number(ctx, -1));
-	return 1;
-}
-#else  /* DUK_USE_REGEXP_SUPPORT */
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNSUPPORTED_ERROR;
-}
-#endif  /* DUK_USE_REGEXP_SUPPORT */
-
-#ifdef DUK_USE_REGEXP_SUPPORT
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_match(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_bool_t global;
-	duk_int_t prev_last_index;
-	duk_int_t this_index;
-	duk_int_t arr_idx;
-
-	DUK_ASSERT_TOP(ctx, 1);
-	(void) duk_push_this_coercible_to_string(ctx);
-	duk__to_regexp_helper(ctx, 0 /*index*/, 0 /*force_new*/);
-	global = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
-	DUK_ASSERT_TOP(ctx, 2);
-
-	/* stack[0] = regexp
-	 * stack[1] = string
-	 */
-
-	if (!global) {
-		duk_regexp_match(thr);  /* -> [ res_obj ] */
-		return 1;  /* return 'res_obj' */
-	}
-
-	/* Global case is more complex. */
-
-	/* [ regexp string ] */
-
-	duk_push_int(ctx, 0);
-	duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-	duk_push_array(ctx);
-
-	/* [ regexp string res_arr ] */
-
-	prev_last_index = 0;
-	arr_idx = 0;
-
-	for (;;) {
-		DUK_ASSERT_TOP(ctx, 3);
-
-		duk_dup(ctx, 0);
-		duk_dup(ctx, 1);
-		duk_regexp_match(thr);  /* -> [ ... regexp string ] -> [ ... res_obj ] */
-
-		if (!duk_is_object(ctx, -1)) {
-			duk_pop(ctx);
-			break;
-		}
-
-		duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-		DUK_ASSERT(duk_is_number(ctx, -1));
-		this_index = duk_get_int(ctx, -1);
-		duk_pop(ctx);
-
-		if (this_index == prev_last_index) {
-			this_index++;
-			duk_push_int(ctx, this_index);
-			duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-		}
-		prev_last_index = this_index;
-
-		duk_get_prop_index(ctx, -1, 0);  /* match string */
-		duk_put_prop_index(ctx, 2, arr_idx);
-		arr_idx++;
-		duk_pop(ctx);  /* res_obj */
-	}
-
-	if (arr_idx == 0) {
-		duk_push_null(ctx);
-	}
-
-	return 1;  /* return 'res_arr' or 'null' */
-}
-#else  /* DUK_USE_REGEXP_SUPPORT */
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_match(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNSUPPORTED_ERROR;
-}
-#endif  /* DUK_USE_REGEXP_SUPPORT */
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_concat(duk_context *ctx) {
-	/* duk_concat() coerces arguments with ToString() in correct order */
-	(void) duk_push_this_coercible_to_string(ctx);
-	duk_insert(ctx, 0);  /* this is relatively expensive */
-	duk_concat(ctx, duk_get_top(ctx));
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_trim(duk_context *ctx) {
-	DUK_ASSERT_TOP(ctx, 0);
-	(void) duk_push_this_coercible_to_string(ctx);
-	duk_trim(ctx, 0);
-	DUK_ASSERT_TOP(ctx, 1);
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_string_prototype_locale_compare(duk_context *ctx) {
-	duk_hstring *h1;
-	duk_hstring *h2;
-	duk_size_t h1_len, h2_len, prefix_len;
-	duk_small_int_t ret = 0;
-	duk_small_int_t rc;
-
-	/* The current implementation of localeCompare() is simply a codepoint
-	 * by codepoint comparison, implemented with a simple string compare
-	 * because UTF-8 should preserve codepoint ordering (assuming valid
-	 * shortest UTF-8 encoding).
-	 *
-	 * The specification requires that the return value must be related
-	 * to the sort order: e.g. negative means that 'this' comes before
-	 * 'that' in sort order.  We assume an ascending sort order.
-	 */
-
-	/* XXX: could share code with duk_js_ops.c, duk_js_compare_helper */
-
-	h1 = duk_push_this_coercible_to_string(ctx);
-	DUK_ASSERT(h1 != NULL);
-
-	h2 = duk_to_hstring(ctx, 0);
-	DUK_ASSERT(h2 != NULL);
-
-	h1_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h1);
-	h2_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h2);
-	prefix_len = (h1_len <= h2_len ? h1_len : h2_len);
-
-	/* Zero size compare not an issue with DUK_MEMCMP. */
-	rc = (duk_small_int_t) DUK_MEMCMP((const void *) DUK_HSTRING_GET_DATA(h1),
-	                                  (const void *) DUK_HSTRING_GET_DATA(h2),
-	                                  (size_t) prefix_len);
-
-	if (rc < 0) {
-		ret = -1;
-		goto done;
-	} else if (rc > 0) {
-		ret = 1;
-		goto done;
-	}
-
-	/* prefix matches, lengths matter now */
-	if (h1_len > h2_len) {
-		ret = 1;
-		goto done;
-	} else if (h1_len == h2_len) {
-		DUK_ASSERT(ret == 0);
-		goto done;
-	}
-	ret = -1;
-	goto done;
-
- done:
-	duk_push_int(ctx, (duk_int_t) ret);
-	return 1;
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/b26ac36e/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_thread.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_thread.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_thread.c
deleted file mode 100644
index 813c8a1..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_thread.c
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
- *  Thread builtins
- */
-
-#include "duk_internal.h"
-
-/*
- *  Constructor
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_thread_constructor(duk_context *ctx) {
-	duk_hthread *new_thr;
-	duk_hobject *func;
-
-	/* XXX: need a duk_require_func_or_lfunc_coerce() */
-	if (!duk_is_callable(ctx, 0)) {
-		return DUK_RET_TYPE_ERROR;
-	}
-	func = duk_require_hobject_or_lfunc_coerce(ctx, 0);
-	DUK_ASSERT(func != NULL);
-
-	duk_push_thread(ctx);
-	new_thr = (duk_hthread *) duk_get_hobject(ctx, -1);
-	DUK_ASSERT(new_thr != NULL);
-	new_thr->state = DUK_HTHREAD_STATE_INACTIVE;
-
-	/* push initial function call to new thread stack; this is
-	 * picked up by resume().
-	 */
-	duk_push_hobject((duk_context *) new_thr, func);
-
-	return 1;  /* return thread */
-}
-
-/*
- *  Resume a thread.
- *
- *  The thread must be in resumable state, either (a) new thread which hasn't
- *  yet started, or (b) a thread which has previously yielded.  This method
- *  must be called from an Ecmascript function.
- *
- *  Args:
- *    - thread
- *    - value
- *    - isError (defaults to false)
- *
- *  Note: yield and resume handling is currently asymmetric.
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_thread_resume(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hthread *thr_resume;
-	duk_tval *tv;
-	duk_hobject *func;
-	duk_hobject *caller_func;
-	duk_small_int_t is_error;
-
-	DUK_DDD(DUK_DDDPRINT("Duktape.Thread.resume(): thread=%!T, value=%!T, is_error=%!T",
-	                     (duk_tval *) duk_get_tval(ctx, 0),
-	                     (duk_tval *) duk_get_tval(ctx, 1),
-	                     (duk_tval *) duk_get_tval(ctx, 2)));
-
-	DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
-	DUK_ASSERT(thr->heap->curr_thread == thr);
-
-	thr_resume = duk_require_hthread(ctx, 0);
-	is_error = (duk_small_int_t) duk_to_boolean(ctx, 2);
-	duk_set_top(ctx, 2);
-
-	/* [ thread value ] */
-
-	/*
-	 *  Thread state and calling context checks
-	 */
-
-	if (thr->callstack_top < 2) {
-		DUK_DD(DUK_DDPRINT("resume state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.resume)"));
-		goto state_error;
-	}
-	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);  /* us */
-	DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
-	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL);  /* caller */
-
-	caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2);
-	if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) {
-		DUK_DD(DUK_DDPRINT("resume state invalid: caller must be Ecmascript code"));
-		goto state_error;
-	}
-
-	/* Note: there is no requirement that: 'thr->callstack_preventcount == 1'
-	 * like for yield.
-	 */
-
-	if (thr_resume->state != DUK_HTHREAD_STATE_INACTIVE &&
-	    thr_resume->state != DUK_HTHREAD_STATE_YIELDED) {
-		DUK_DD(DUK_DDPRINT("resume state invalid: target thread must be INACTIVE or YIELDED"));
-		goto state_error;
-	}
-
-	DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE ||
-	           thr_resume->state == DUK_HTHREAD_STATE_YIELDED);
-
-	/* Further state-dependent pre-checks */
-
-	if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
-		/* no pre-checks now, assume a previous yield() has left things in
-		 * tip-top shape (longjmp handler will assert for these).
-		 */
-	} else {
-		DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE);
-
-		if ((thr_resume->callstack_top != 0) ||
-		    (thr_resume->valstack_top - thr_resume->valstack != 1)) {
-			goto state_invalid_initial;
-		}
-		tv = &thr_resume->valstack_top[-1];
-		DUK_ASSERT(tv >= thr_resume->valstack && tv < thr_resume->valstack_top);
-		if (!DUK_TVAL_IS_OBJECT(tv)) {
-			goto state_invalid_initial;
-		}
-		func = DUK_TVAL_GET_OBJECT(tv);
-		DUK_ASSERT(func != NULL);
-		if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
-			/* Note: cannot be a bound function either right now,
-			 * this would be easy to relax though.
-			 */
-			goto state_invalid_initial;
-		}
-
-	}
-
-	/*
-	 *  The error object has been augmented with a traceback and other
-	 *  info from its creation point -- usually another thread.  The
-	 *  error handler is called here right before throwing, but it also
-	 *  runs in the resumer's thread.  It might be nice to get a traceback
-	 *  from the resumee but this is not the case now.
-	 */
-
-#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-	if (is_error) {
-		DUK_ASSERT_TOP(ctx, 2);  /* value (error) is at stack top */
-		duk_err_augment_error_throw(thr);  /* in resumer's context */
-	}
-#endif
-
-#ifdef DUK_USE_DEBUG
-	if (is_error) {
-		DUK_DDD(DUK_DDDPRINT("RESUME ERROR: thread=%!T, value=%!T",
-		                     (duk_tval *) duk_get_tval(ctx, 0),
-		                     (duk_tval *) duk_get_tval(ctx, 1)));
-	} else if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
-		DUK_DDD(DUK_DDDPRINT("RESUME NORMAL: thread=%!T, value=%!T",
-		                     (duk_tval *) duk_get_tval(ctx, 0),
-		                     (duk_tval *) duk_get_tval(ctx, 1)));
-	} else {
-		DUK_DDD(DUK_DDDPRINT("RESUME INITIAL: thread=%!T, value=%!T",
-		                     (duk_tval *) duk_get_tval(ctx, 0),
-		                     (duk_tval *) duk_get_tval(ctx, 1)));
-	}
-#endif
-
-	thr->heap->lj.type = DUK_LJ_TYPE_RESUME;
-
-	/* lj value2: thread */
-	DUK_ASSERT(thr->valstack_bottom < thr->valstack_top);
-	DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value2, &thr->valstack_bottom[0]);  /* side effects */
-
-	/* lj value1: value */
-	DUK_ASSERT(thr->valstack_bottom + 1 < thr->valstack_top);
-	DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value1, &thr->valstack_bottom[1]);  /* side effects */
-	DUK_TVAL_CHKFAST_INPLACE(&thr->heap->lj.value1);
-
-	thr->heap->lj.iserror = is_error;
-
-	DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* call is from executor, so we know we have a jmpbuf */
-	duk_err_longjmp(thr);  /* execution resumes in bytecode executor */
-	return 0;  /* never here */
-
- state_invalid_initial:
-	DUK_ERROR_TYPE(thr, "invalid initial thread state/stack");
-	return 0;  /* never here */
-
- state_error:
-	DUK_ERROR_TYPE(thr, "invalid state");
-	return 0;  /* never here */
-}
-
-/*
- *  Yield the current thread.
- *
- *  The thread must be in yieldable state: it must have a resumer, and there
- *  must not be any yield-preventing calls (native calls and constructor calls,
- *  currently) in the thread's call stack (otherwise a resume would not be
- *  possible later).  This method must be called from an Ecmascript function.
- *
- *  Args:
- *    - value
- *    - isError (defaults to false)
- *
- *  Note: yield and resume handling is currently asymmetric.
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_thread_yield(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hobject *caller_func;
-	duk_small_int_t is_error;
-
-	DUK_DDD(DUK_DDDPRINT("Duktape.Thread.yield(): value=%!T, is_error=%!T",
-	                     (duk_tval *) duk_get_tval(ctx, 0),
-	                     (duk_tval *) duk_get_tval(ctx, 1)));
-
-	DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
-	DUK_ASSERT(thr->heap->curr_thread == thr);
-
-	is_error = (duk_small_int_t) duk_to_boolean(ctx, 1);
-	duk_set_top(ctx, 1);
-
-	/* [ value ] */
-
-	/*
-	 *  Thread state and calling context checks
-	 */
-
-	if (!thr->resumer) {
-		DUK_DD(DUK_DDPRINT("yield state invalid: current thread must have a resumer"));
-		goto state_error;
-	}
-	DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED);
-
-	if (thr->callstack_top < 2) {
-		DUK_DD(DUK_DDPRINT("yield state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.yield)"));
-		goto state_error;
-	}
-	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);  /* us */
-	DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
-	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL);  /* caller */
-
-	caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2);
-	if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) {
-		DUK_DD(DUK_DDPRINT("yield state invalid: caller must be Ecmascript code"));
-		goto state_error;
-	}
-
-	DUK_ASSERT(thr->callstack_preventcount >= 1);  /* should never be zero, because we (Duktape.Thread.yield) are on the stack */
-	if (thr->callstack_preventcount != 1) {
-		/* Note: the only yield-preventing call is Duktape.Thread.yield(), hence check for 1, not 0 */
-		DUK_DD(DUK_DDPRINT("yield state invalid: there must be no yield-preventing calls in current thread callstack (preventcount is %ld)",
-		                   (long) thr->callstack_preventcount));
-		goto state_error;
-	}
-
-	/*
-	 *  The error object has been augmented with a traceback and other
-	 *  info from its creation point -- usually the current thread.
-	 *  The error handler, however, is called right before throwing
-	 *  and runs in the yielder's thread.
-	 */
-
-#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-	if (is_error) {
-		DUK_ASSERT_TOP(ctx, 1);  /* value (error) is at stack top */
-		duk_err_augment_error_throw(thr);  /* in yielder's context */
-	}
-#endif
-
-#ifdef DUK_USE_DEBUG
-	if (is_error) {
-		DUK_DDD(DUK_DDDPRINT("YIELD ERROR: value=%!T",
-		                     (duk_tval *) duk_get_tval(ctx, 0)));
-	} else {
-		DUK_DDD(DUK_DDDPRINT("YIELD NORMAL: value=%!T",
-		                     (duk_tval *) duk_get_tval(ctx, 0)));
-	}
-#endif
-
-	/*
-	 *  Process yield
-	 *
-	 *  After longjmp(), processing continues in bytecode executor longjmp
-	 *  handler, which will e.g. update thr->resumer to NULL.
-	 */
-
-	thr->heap->lj.type = DUK_LJ_TYPE_YIELD;
-
-	/* lj value1: value */
-	DUK_ASSERT(thr->valstack_bottom < thr->valstack_top);
-	DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value1, &thr->valstack_bottom[0]);  /* side effects */
-	DUK_TVAL_CHKFAST_INPLACE(&thr->heap->lj.value1);
-
-	thr->heap->lj.iserror = is_error;
-
-	DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* call is from executor, so we know we have a jmpbuf */
-	duk_err_longjmp(thr);  /* execution resumes in bytecode executor */
-	return 0;  /* never here */
-
- state_error:
-	DUK_ERROR_TYPE(thr, "invalid state");
-	return 0;  /* never here */
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_thread_current(duk_context *ctx) {
-	duk_push_current_thread(ctx);
-	return 1;
-}

http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/b26ac36e/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_thrower.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_thrower.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_thrower.c
deleted file mode 100644
index a71512a..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_bi_thrower.c
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- *  Type error thrower, E5 Section 13.2.3.
- */
-
-#include "duk_internal.h"
-
-DUK_INTERNAL duk_ret_t duk_bi_type_error_thrower(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_TYPE_ERROR;
-}


Mime
View raw message