Mailing-List: contact commits-help@nifi.apache.org; run by ezmlm
Precedence: bulk
Reply-To: dev@nifi.apache.org
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
From: phrocker@apache.org
To: commits@nifi.apache.org
Date: Tue, 02 Jan 2018 18:28:21 -0000
Message-Id: <adfafc7d6bf3437898b6ddd97a0e0e31@git.apache.org>
In-Reply-To: <393125fe9d4f4240ad0d4ebb59d982bb@git.apache.org>
References: <393125fe9d4f4240ad0d4ebb59d982bb@git.apache.org>
Subject: [26/51] [partial] nifi-minifi-cpp git commit: MINIFICPP-351: Remove
 Civetweb third party directory
archived-at: Tue, 02 Jan 2018 18:28:12 -0000

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_bi_logger.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_logger.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_logger.c
deleted file mode 100644
index d2b89e5..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_logger.c
+++ /dev/null
@@ -1,300 +0,0 @@
-/*
- *  Logging support
- */
-
-#include "duk_internal.h"
-
-/* 3-letter log level strings */
-DUK_LOCAL const duk_uint8_t duk__log_level_strings[] = {
-	(duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_C,
-	(duk_uint8_t) DUK_ASC_UC_D, (duk_uint8_t) DUK_ASC_UC_B, (duk_uint8_t) DUK_ASC_UC_G,
-	(duk_uint8_t) DUK_ASC_UC_I, (duk_uint8_t) DUK_ASC_UC_N, (duk_uint8_t) DUK_ASC_UC_F,
-	(duk_uint8_t) DUK_ASC_UC_W, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_N,
-	(duk_uint8_t) DUK_ASC_UC_E, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_R,
-	(duk_uint8_t) DUK_ASC_UC_F, (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_L
-};
-
-/* Constructor */
-DUK_INTERNAL duk_ret_t duk_bi_logger_constructor(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_idx_t nargs;
-
-	/* Calling as a non-constructor is not meaningful. */
-	if (!duk_is_constructor_call(ctx)) {
-		return DUK_RET_TYPE_ERROR;
-	}
-
-	nargs = duk_get_top(ctx);
-	duk_set_top(ctx, 1);
-
-	duk_push_this(ctx);
-
-	/* [ name this ] */
-
-	if (nargs == 0) {
-		/* Automatic defaulting of logger name from caller.  This would
-		 * work poorly with tail calls, but constructor calls are currently
-		 * never tail calls, so tail calls are not an issue now.
-		 */
-
-		if (thr->callstack_top >= 2) {
-			duk_activation *act_caller = thr->callstack + thr->callstack_top - 2;
-			duk_hobject *func_caller;
-
-			func_caller = DUK_ACT_GET_FUNC(act_caller);
-			if (func_caller) {
-				/* Stripping the filename might be a good idea
-				 * ("/foo/bar/quux.js" -> logger name "quux"),
-				 * but now used verbatim.
-				 */
-				duk_push_hobject(ctx, func_caller);
-				duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME);
-				duk_replace(ctx, 0);
-			}
-		}
-	}
-	/* the stack is unbalanced here on purpose; we only rely on the
-	 * initial two values: [ name this ].
-	 */
-
-	if (duk_is_string(ctx, 0)) {
-		duk_dup(ctx, 0);
-		duk_put_prop_stridx(ctx, 1, DUK_STRIDX_LC_N);
-	} else {
-		/* don't set 'n' at all, inherited value is used as name */
-	}
-
-	duk_compact(ctx, 1);
-
-	return 0;  /* keep default instance */
-}
-
-/* Default function to format objects.  Tries to use toLogString() but falls
- * back to toString().  Any errors are propagated out without catching.
- */
-DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_fmt(duk_context *ctx) {
-	if (duk_get_prop_stridx(ctx, 0, DUK_STRIDX_TO_LOG_STRING)) {
-		/* [ arg toLogString ] */
-
-		duk_dup(ctx, 0);
-		duk_call_method(ctx, 0);
-
-		/* [ arg result ] */
-		return 1;
-	}
-
-	/* [ arg undefined ] */
-	duk_pop(ctx);
-	duk_to_string(ctx, 0);
-	return 1;
-}
-
-/* Default function to write a formatted log line.  Writes to stderr,
- * appending a newline to the log line.
- *
- * The argument is a buffer whose visible size contains the log message.
- * This function should avoid coercing the buffer to a string to avoid
- * string table traffic.
- */
-DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_raw(duk_context *ctx) {
-	const char *data;
-	duk_size_t data_len;
-
-	DUK_UNREF(ctx);
-	DUK_UNREF(data);
-	DUK_UNREF(data_len);
-
-#ifdef DUK_USE_FILE_IO
-	data = (const char *) duk_require_buffer(ctx, 0, &data_len);
-	DUK_FWRITE((const void *) data, 1, data_len, DUK_STDERR);
-	DUK_FPUTC((int) '\n', DUK_STDERR);
-	DUK_FFLUSH(DUK_STDERR);
-#else
-	/* nop */
-#endif
-	return 0;
-}
-
-/* Log frontend shared helper, magic value indicates log level.  Provides
- * frontend functions: trace(), debug(), info(), warn(), error(), fatal().
- * This needs to have small footprint, reasonable performance, minimal
- * memory churn, etc.
- */
-DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_log_shared(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_double_t now;
-	duk_small_int_t entry_lev = duk_get_current_magic(ctx);
-	duk_small_int_t logger_lev;
-	duk_int_t nargs;
-	duk_int_t i;
-	duk_size_t tot_len;
-	const duk_uint8_t *arg_str;
-	duk_size_t arg_len;
-	duk_uint8_t *buf, *p;
-	const duk_uint8_t *q;
-	duk_uint8_t date_buf[DUK_BI_DATE_ISO8601_BUFSIZE];
-	duk_size_t date_len;
-	duk_small_int_t rc;
-
-	DUK_ASSERT(entry_lev >= 0 && entry_lev <= 5);
-	DUK_UNREF(thr);
-
-	/* XXX: sanitize to printable (and maybe ASCII) */
-	/* XXX: better multiline */
-
-	/*
-	 *  Logger arguments are:
-	 *
-	 *    magic: log level (0-5)
-	 *    this: logger
-	 *    stack: plain log args
-	 *
-	 *  We want to minimize memory churn so a two-pass approach
-	 *  is used: first pass formats arguments and computes final
-	 *  string length, second pass copies strings either into a
-	 *  pre-allocated and reused buffer (short messages) or into a
-	 *  newly allocated fixed buffer.  If the backend function plays
-	 *  nice, it won't coerce the buffer to a string (and thus
-	 *  intern it).
-	 */
-
-	nargs = duk_get_top(ctx);
-
-	/* [ arg1 ... argN this ] */
-
-	/*
-	 *  Log level check
-	 */
-
-	duk_push_this(ctx);
-
-	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LC_L);
-	logger_lev = (duk_small_int_t) duk_get_int(ctx, -1);
-	if (entry_lev < logger_lev) {
-		return 0;
-	}
-	/* log level could be popped but that's not necessary */
-
-	now = DUK_USE_DATE_GET_NOW(ctx);
-	duk_bi_date_format_timeval(now, date_buf);
-	date_len = DUK_STRLEN((const char *) date_buf);
-
-	duk_get_prop_stridx(ctx, -2, DUK_STRIDX_LC_N);
-	duk_to_string(ctx, -1);
-	DUK_ASSERT(duk_is_string(ctx, -1));
-
-	/* [ arg1 ... argN this loggerLevel loggerName ] */
-
-	/*
-	 *  Pass 1
-	 */
-
-	/* Line format: <time> <entryLev> <loggerName>: <msg> */
-
-	tot_len = 0;
-	tot_len += 3 +  /* separators: space, space, colon */
-	           3 +  /* level string */
-	           date_len +  /* time */
-	           duk_get_length(ctx, -1);  /* loggerName */
-
-	for (i = 0; i < nargs; i++) {
-		/* When formatting an argument to a string, errors may happen from multiple
-		 * causes.  In general we want to catch obvious errors like a toLogString()
-		 * throwing an error, but we don't currently try to catch every possible
-		 * error.  In particular, internal errors (like out of memory or stack) are
-		 * not caught.  Also, we expect Error toString() to not throw an error.
-		 */
-		if (duk_is_object(ctx, i)) {
-			/* duk_pcall_prop() may itself throw an error, but we're content
-			 * in catching the obvious errors (like toLogString() throwing an
-			 * error).
-			 */
-			duk_push_hstring_stridx(ctx, DUK_STRIDX_FMT);
-			duk_dup(ctx, i);
-			/* [ arg1 ... argN this loggerLevel loggerName 'fmt' arg ] */
-			/* call: this.fmt(arg) */
-			rc = duk_pcall_prop(ctx, -5 /*obj_index*/, 1 /*nargs*/);
-			if (rc) {
-				/* Keep the error as the result (coercing it might fail below,
-				 * but we don't catch that now).
-				 */
-				;
-			}
-			duk_replace(ctx, i);
-		}
-		(void) duk_to_lstring(ctx, i, &arg_len);
-		tot_len++;  /* sep (even before first one) */
-		tot_len += arg_len;
-	}
-
-	/*
-	 *  Pass 2
-	 */
-
-	/* XXX: There used to be a shared log buffer here, but it was removed
-	 * when dynamic buffer spare was removed.  The problem with using
-	 * bufwriter is that, without the spare, the buffer gets passed on
-	 * as an argument to the raw() call so it'd need to be resized
-	 * (reallocated) anyway.  If raw() call convention is changed, this
-	 * could be made more efficient.
-	 */
-
-	buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, tot_len);
-	DUK_ASSERT(buf != NULL);
-	p = buf;
-
-	DUK_MEMCPY((void *) p, (const void *) date_buf, (size_t) date_len);
-	p += date_len;
-	*p++ = (duk_uint8_t) DUK_ASC_SPACE;
-
-	q = duk__log_level_strings + (entry_lev * 3);
-	DUK_MEMCPY((void *) p, (const void *) q, (size_t) 3);
-	p += 3;
-
-	*p++ = (duk_uint8_t) DUK_ASC_SPACE;
-
-	arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, -2, &arg_len);
-	DUK_MEMCPY((void *) p, (const void *) arg_str, (size_t) arg_len);
-	p += arg_len;
-
-	*p++ = (duk_uint8_t) DUK_ASC_COLON;
-
-	for (i = 0; i < nargs; i++) {
-		*p++ = (duk_uint8_t) DUK_ASC_SPACE;
-
-		arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &arg_len);
-		DUK_ASSERT(arg_str != NULL);
-		DUK_MEMCPY((void *) p, (const void *) arg_str, (size_t) arg_len);
-		p += arg_len;
-	}
-	DUK_ASSERT(buf + tot_len == p);
-
-	/* [ arg1 ... argN this loggerLevel loggerName buffer ] */
-
-#if defined(DUK_USE_DEBUGGER_SUPPORT) && defined(DUK_USE_DEBUGGER_FWD_LOGGING)
-	/* Do debugger forwarding before raw() because the raw() function
-	 * doesn't get the log level right now.
-	 */
-	if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
-		const char *log_buf;
-		duk_size_t sz_buf;
-		log_buf = (const char *) duk_get_buffer(ctx, -1, &sz_buf);
-		DUK_ASSERT(log_buf != NULL);
-		duk_debug_write_notify(thr, DUK_DBG_CMD_LOG);
-		duk_debug_write_int(thr, (duk_int32_t) entry_lev);
-		duk_debug_write_string(thr, (const char *) log_buf, sz_buf);
-		duk_debug_write_eom(thr);
-	}
-#endif
-
-	/* Call this.raw(msg); look up through the instance allows user to override
-	 * the raw() function in the instance or in the prototype for maximum
-	 * flexibility.
-	 */
-	duk_push_hstring_stridx(ctx, DUK_STRIDX_RAW);
-	duk_dup(ctx, -2);
-	/* [ arg1 ... argN this loggerLevel loggerName buffer 'raw' buffer ] */
-	duk_call_prop(ctx, -6, 1);  /* this.raw(buffer) */
-
-	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_bi_math.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_math.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_math.c
deleted file mode 100644
index 62c9341..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_math.c
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
- *  Math built-ins
- */
-
-#include "duk_internal.h"
-
-#if defined(DUK_USE_MATH_BUILTIN)
-
-/*
- *  Use static helpers which can work with math.h functions matching
- *  the following signatures. This is not portable if any of these math
- *  functions is actually a macro.
- *
- *  Typing here is intentionally 'double' wherever values interact with
- *  the standard library APIs.
- */
-
-typedef double (*duk__one_arg_func)(double);
-typedef double (*duk__two_arg_func)(double, double);
-
-DUK_LOCAL duk_ret_t duk__math_minmax(duk_context *ctx, duk_double_t initial, duk__two_arg_func min_max) {
-	duk_idx_t n = duk_get_top(ctx);
-	duk_idx_t i;
-	duk_double_t res = initial;
-	duk_double_t t;
-
-	/*
-	 *  Note: fmax() does not match the E5 semantics.  E5 requires
-	 *  that if -any- input to Math.max() is a NaN, the result is a
-	 *  NaN.  fmax() will return a NaN only if -both- inputs are NaN.
-	 *  Same applies to fmin().
-	 *
-	 *  Note: every input value must be coerced with ToNumber(), even
-	 *  if we know the result will be a NaN anyway: ToNumber() may have
-	 *  side effects for which even order of evaluation matters.
-	 */
-
-	for (i = 0; i < n; i++) {
-		t = duk_to_number(ctx, i);
-		if (DUK_FPCLASSIFY(t) == DUK_FP_NAN || DUK_FPCLASSIFY(res) == DUK_FP_NAN) {
-			/* Note: not normalized, but duk_push_number() will normalize */
-			res = (duk_double_t) DUK_DOUBLE_NAN;
-		} else {
-			res = (duk_double_t) min_max(res, (double) t);
-		}
-	}
-
-	duk_push_number(ctx, res);
-	return 1;
-}
-
-DUK_LOCAL double duk__fmin_fixed(double x, double y) {
-	/* fmin() with args -0 and +0 is not guaranteed to return
-	 * -0 as Ecmascript requires.
-	 */
-	if (x == 0 && y == 0) {
-		/* XXX: what's the safest way of creating a negative zero? */
-		if (DUK_SIGNBIT(x) != 0 || DUK_SIGNBIT(y) != 0) {
-			return -0.0;
-		} else {
-			return +0.0;
-		}
-	}
-#ifdef DUK_USE_MATH_FMIN
-	return DUK_FMIN(x, y);
-#else
-	return (x < y ? x : y);
-#endif
-}
-
-DUK_LOCAL double duk__fmax_fixed(double x, double y) {
-	/* fmax() with args -0 and +0 is not guaranteed to return
-	 * +0 as Ecmascript requires.
-	 */
-	if (x == 0 && y == 0) {
-		if (DUK_SIGNBIT(x) == 0 || DUK_SIGNBIT(y) == 0) {
-			return +0.0;
-		} else {
-			return -0.0;
-		}
-	}
-#ifdef DUK_USE_MATH_FMAX
-	return DUK_FMAX(x, y);
-#else
-	return (x > y ? x : y);
-#endif
-}
-
-DUK_LOCAL double duk__round_fixed(double x) {
-	/* Numbers half-way between integers must be rounded towards +Infinity,
-	 * e.g. -3.5 must be rounded to -3 (not -4).  When rounded to zero, zero
-	 * sign must be set appropriately.  E5.1 Section 15.8.2.15.
-	 *
-	 * Note that ANSI C round() is "round to nearest integer, away from zero",
-	 * which is incorrect for negative values.  Here we make do with floor().
-	 */
-
-	duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x);
-	if (c == DUK_FP_NAN || c == DUK_FP_INFINITE || c == DUK_FP_ZERO) {
-		return x;
-	}
-
-	/*
-	 *  x is finite and non-zero
-	 *
-	 *  -1.6 -> floor(-1.1) -> -2
-	 *  -1.5 -> floor(-1.0) -> -1  (towards +Inf)
-	 *  -1.4 -> floor(-0.9) -> -1
-	 *  -0.5 -> -0.0               (special case)
-	 *  -0.1 -> -0.0               (special case)
-	 *  +0.1 -> +0.0               (special case)
-	 *  +0.5 -> floor(+1.0) -> 1   (towards +Inf)
-	 *  +1.4 -> floor(+1.9) -> 1
-	 *  +1.5 -> floor(+2.0) -> 2   (towards +Inf)
-	 *  +1.6 -> floor(+2.1) -> 2
-	 */
-
-	if (x >= -0.5 && x < 0.5) {
-		/* +0.5 is handled by floor, this is on purpose */
-		if (x < 0.0) {
-			return -0.0;
-		} else {
-			return +0.0;
-		}
-	}
-
-	return DUK_FLOOR(x + 0.5);
-}
-
-DUK_LOCAL double duk__pow_fixed(double x, double y) {
-	/* The ANSI C pow() semantics differ from Ecmascript.
-	 *
-	 * E.g. when x==1 and y is +/- infinite, the Ecmascript required
-	 * result is NaN, while at least Linux pow() returns 1.
-	 */
-
-	duk_small_int_t cx, cy, sx;
-
-	DUK_UNREF(cx);
-	DUK_UNREF(sx);
-	cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
-
-	if (cy == DUK_FP_NAN) {
-		goto ret_nan;
-	}
-	if (DUK_FABS(x) == 1.0 && cy == DUK_FP_INFINITE) {
-		goto ret_nan;
-	}
-#if defined(DUK_USE_POW_NETBSD_WORKAROUND)
-	/* See test-bug-netbsd-math-pow.js: NetBSD 6.0 on x86 (at least) does not
-	 * correctly handle some cases where x=+/-0.  Specific fixes to these
-	 * here.
-	 */
-	cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
-	if (cx == DUK_FP_ZERO && y < 0.0) {
-		sx = (duk_small_int_t) DUK_SIGNBIT(x);
-		if (sx == 0) {
-			/* Math.pow(+0,y) should be Infinity when y<0.  NetBSD pow()
-			 * returns -Infinity instead when y is <0 and finite.  The
-			 * if-clause also catches y == -Infinity (which works even
-			 * without the fix).
-			 */
-			return DUK_DOUBLE_INFINITY;
-		} else {
-			/* Math.pow(-0,y) where y<0 should be:
-			 *   - -Infinity if y<0 and an odd integer
-			 *   - Infinity otherwise
-			 * NetBSD pow() returns -Infinity for all finite y<0.  The
-			 * if-clause also catches y == -Infinity (which works even
-			 * without the fix).
-			 */
-
-			/* fmod() return value has same sign as input (negative) so
-			 * the result here will be in the range ]-2,0], 1 indicates
-			 * odd.  If x is -Infinity, NaN is returned and the odd check
-			 * always concludes "not odd" which results in desired outcome.
-			 */
-			double tmp = DUK_FMOD(y, 2);
-			if (tmp == -1.0) {
-				return -DUK_DOUBLE_INFINITY;
-			} else {
-				/* Not odd, or y == -Infinity */
-				return DUK_DOUBLE_INFINITY;
-			}
-		}
-	}
-#endif
-	return DUK_POW(x, y);
-
- ret_nan:
-	return DUK_DOUBLE_NAN;
-}
-
-/* Wrappers for calling standard math library methods.  These may be required
- * on platforms where one or more of the math built-ins are defined as macros
- * or inline functions and are thus not suitable to be used as function pointers.
- */
-#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
-DUK_LOCAL double duk__fabs(double x) {
-	return DUK_FABS(x);
-}
-DUK_LOCAL double duk__acos(double x) {
-	return DUK_ACOS(x);
-}
-DUK_LOCAL double duk__asin(double x) {
-	return DUK_ASIN(x);
-}
-DUK_LOCAL double duk__atan(double x) {
-	return DUK_ATAN(x);
-}
-DUK_LOCAL double duk__ceil(double x) {
-	return DUK_CEIL(x);
-}
-DUK_LOCAL double duk__cos(double x) {
-	return DUK_COS(x);
-}
-DUK_LOCAL double duk__exp(double x) {
-	return DUK_EXP(x);
-}
-DUK_LOCAL double duk__floor(double x) {
-	return DUK_FLOOR(x);
-}
-DUK_LOCAL double duk__log(double x) {
-	return DUK_LOG(x);
-}
-DUK_LOCAL double duk__sin(double x) {
-	return DUK_SIN(x);
-}
-DUK_LOCAL double duk__sqrt(double x) {
-	return DUK_SQRT(x);
-}
-DUK_LOCAL double duk__tan(double x) {
-	return DUK_TAN(x);
-}
-DUK_LOCAL double duk__atan2(double x, double y) {
-	return DUK_ATAN2(x, y);
-}
-#endif  /* DUK_USE_AVOID_PLATFORM_FUNCPTRS */
-
-/* order must match constants in genbuiltins.py */
-DUK_LOCAL const duk__one_arg_func duk__one_arg_funcs[] = {
-#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
-	duk__fabs,
-	duk__acos,
-	duk__asin,
-	duk__atan,
-	duk__ceil,
-	duk__cos,
-	duk__exp,
-	duk__floor,
-	duk__log,
-	duk__round_fixed,
-	duk__sin,
-	duk__sqrt,
-	duk__tan
-#else
-	DUK_FABS,
-	DUK_ACOS,
-	DUK_ASIN,
-	DUK_ATAN,
-	DUK_CEIL,
-	DUK_COS,
-	DUK_EXP,
-	DUK_FLOOR,
-	DUK_LOG,
-	duk__round_fixed,
-	DUK_SIN,
-	DUK_SQRT,
-	DUK_TAN
-#endif
-};
-
-/* order must match constants in genbuiltins.py */
-DUK_LOCAL const duk__two_arg_func duk__two_arg_funcs[] = {
-#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
-	duk__atan2,
-	duk__pow_fixed
-#else
-	DUK_ATAN2,
-	duk__pow_fixed
-#endif
-};
-
-DUK_INTERNAL duk_ret_t duk_bi_math_object_onearg_shared(duk_context *ctx) {
-	duk_small_int_t fun_idx = duk_get_current_magic(ctx);
-	duk__one_arg_func fun;
-
-	DUK_ASSERT(fun_idx >= 0);
-	DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__one_arg_funcs) / sizeof(duk__one_arg_func)));
-	fun = duk__one_arg_funcs[fun_idx];
-	duk_push_number(ctx, (duk_double_t) fun((double) duk_to_number(ctx, 0)));
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_math_object_twoarg_shared(duk_context *ctx) {
-	duk_small_int_t fun_idx = duk_get_current_magic(ctx);
-	duk__two_arg_func fun;
-
-	DUK_ASSERT(fun_idx >= 0);
-	DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__two_arg_funcs) / sizeof(duk__two_arg_func)));
-	fun = duk__two_arg_funcs[fun_idx];
-	duk_push_number(ctx, (duk_double_t) fun((double) duk_to_number(ctx, 0), (double) duk_to_number(ctx, 1)));
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_math_object_max(duk_context *ctx) {
-	return duk__math_minmax(ctx, -DUK_DOUBLE_INFINITY, duk__fmax_fixed);
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_math_object_min(duk_context *ctx) {
-	return duk__math_minmax(ctx, DUK_DOUBLE_INFINITY, duk__fmin_fixed);
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_math_object_random(duk_context *ctx) {
-	duk_push_number(ctx, (duk_double_t) duk_util_tinyrandom_get_double((duk_hthread *) ctx));
-	return 1;
-}
-
-#else  /* DUK_USE_MATH_BUILTIN */
-
-/* A stubbed built-in is useful for e.g. compilation torture testing with BCC. */
-
-DUK_INTERNAL duk_ret_t duk_bi_math_object_onearg_shared(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNIMPLEMENTED_ERROR;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_math_object_twoarg_shared(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNIMPLEMENTED_ERROR;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_math_object_max(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNIMPLEMENTED_ERROR;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_math_object_min(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNIMPLEMENTED_ERROR;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_math_object_random(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNIMPLEMENTED_ERROR;
-}
-
-#endif  /* DUK_USE_MATH_BUILTIN */

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_bi_number.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_number.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_number.c
deleted file mode 100644
index 4b7abf5..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_number.c
+++ /dev/null
@@ -1,240 +0,0 @@
-/*
- *  Number built-ins
- */
-
-#include "duk_internal.h"
-
-DUK_LOCAL duk_double_t duk__push_this_number_plain(duk_context *ctx) {
-	duk_hobject *h;
-
-	/* Number built-in accepts a plain number or a Number object (whose
-	 * internal value is operated on).  Other types cause TypeError.
-	 */
-
-	duk_push_this(ctx);
-	if (duk_is_number(ctx, -1)) {
-		DUK_DDD(DUK_DDDPRINT("plain number value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
-		goto done;
-	}
-	h = duk_get_hobject(ctx, -1);
-	if (!h ||
-	    (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_NUMBER)) {
-		DUK_DDD(DUK_DDDPRINT("unacceptable this value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
-		DUK_ERROR_TYPE((duk_hthread *) ctx, "number expected");
-	}
-	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
-	DUK_ASSERT(duk_is_number(ctx, -1));
-	DUK_DDD(DUK_DDDPRINT("number object: %!T, internal value: %!T",
-	                     (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
-	duk_remove(ctx, -2);
-
- done:
-	return duk_get_number(ctx, -1);
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_number_constructor(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_idx_t nargs;
-	duk_hobject *h_this;
-
-	DUK_UNREF(thr);
-
-	/*
-	 *  The Number constructor uses ToNumber(arg) for number coercion
-	 *  (coercing an undefined argument to NaN).  However, if the
-	 *  argument is not given at all, +0 must be used instead.  To do
-	 *  this, a vararg function is used.
-	 */
-
-	nargs = duk_get_top(ctx);
-	if (nargs == 0) {
-		duk_push_int(ctx, 0);
-	}
-	duk_to_number(ctx, 0);
-	duk_set_top(ctx, 1);
-	DUK_ASSERT_TOP(ctx, 1);
-
-	if (!duk_is_constructor_call(ctx)) {
-		return 1;
-	}
-
-	/*
-	 *  E5 Section 15.7.2.1 requires that the constructed object
-	 *  must have the original Number.prototype as its internal
-	 *  prototype.  However, since Number.prototype is non-writable
-	 *  and non-configurable, this doesn't have to be enforced here:
-	 *  The default object (bound to 'this') is OK, though we have
-	 *  to change its class.
-	 *
-	 *  Internal value set to ToNumber(arg) or +0; if no arg given,
-	 *  ToNumber(undefined) = NaN, so special treatment is needed
-	 *  (above).  String internal value is immutable.
-	 */
-
-	/* XXX: helper */
-	duk_push_this(ctx);
-	h_this = duk_get_hobject(ctx, -1);
-	DUK_ASSERT(h_this != NULL);
-	DUK_HOBJECT_SET_CLASS_NUMBER(h_this, DUK_HOBJECT_CLASS_NUMBER);
-
-	DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_this) == thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE]);
-	DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(h_this) == DUK_HOBJECT_CLASS_NUMBER);
-	DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h_this));
-
-	duk_dup(ctx, 0);  /* -> [ val obj val ] */
-	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
-	return 0;  /* no return value -> don't replace created value */
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_number_prototype_value_of(duk_context *ctx) {
-	(void) duk__push_this_number_plain(ctx);
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_string(duk_context *ctx) {
-	duk_small_int_t radix;
-	duk_small_uint_t n2s_flags;
-
-	(void) duk__push_this_number_plain(ctx);
-	if (duk_is_undefined(ctx, 0)) {
-		radix = 10;
-	} else {
-		radix = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 2, 36);
-	}
-	DUK_DDD(DUK_DDDPRINT("radix=%ld", (long) radix));
-
-	n2s_flags = 0;
-
-	duk_numconv_stringify(ctx,
-	                      radix /*radix*/,
-	                      0 /*digits*/,
-	                      n2s_flags /*flags*/);
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_locale_string(duk_context *ctx) {
-	/* XXX: just use toString() for now; permitted although not recommended.
-	 * nargs==1, so radix is passed to toString().
-	 */
-	return duk_bi_number_prototype_to_string(ctx);
-}
-
-/*
- *  toFixed(), toExponential(), toPrecision()
- */
-
-/* XXX: shared helper for toFixed(), toExponential(), toPrecision()? */
-
-DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_fixed(duk_context *ctx) {
-	duk_small_int_t frac_digits;
-	duk_double_t d;
-	duk_small_int_t c;
-	duk_small_uint_t n2s_flags;
-
-	frac_digits = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 0, 20);
-	d = duk__push_this_number_plain(ctx);
-
-	c = (duk_small_int_t) DUK_FPCLASSIFY(d);
-	if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
-		goto use_to_string;
-	}
-
-	if (d >= 1.0e21 || d <= -1.0e21) {
-		goto use_to_string;
-	}
-
-	n2s_flags = DUK_N2S_FLAG_FIXED_FORMAT |
-	            DUK_N2S_FLAG_FRACTION_DIGITS;
-
-	duk_numconv_stringify(ctx,
-	                      10 /*radix*/,
-	                      frac_digits /*digits*/,
-	                      n2s_flags /*flags*/);
-	return 1;
-
- use_to_string:
-	DUK_ASSERT_TOP(ctx, 2);
-	duk_to_string(ctx, -1);
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_exponential(duk_context *ctx) {
-	duk_bool_t frac_undefined;
-	duk_small_int_t frac_digits;
-	duk_double_t d;
-	duk_small_int_t c;
-	duk_small_uint_t n2s_flags;
-
-	d = duk__push_this_number_plain(ctx);
-
-	frac_undefined = duk_is_undefined(ctx, 0);
-	duk_to_int(ctx, 0);  /* for side effects */
-
-	c = (duk_small_int_t) DUK_FPCLASSIFY(d);
-	if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
-		goto use_to_string;
-	}
-
-	frac_digits = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 0, 20);
-
-	n2s_flags = DUK_N2S_FLAG_FORCE_EXP |
-	           (frac_undefined ? 0 : DUK_N2S_FLAG_FIXED_FORMAT);
-
-	duk_numconv_stringify(ctx,
-	                      10 /*radix*/,
-	                      frac_digits + 1 /*leading digit + fractions*/,
-	                      n2s_flags /*flags*/);
-	return 1;
-
- use_to_string:
-	DUK_ASSERT_TOP(ctx, 2);
-	duk_to_string(ctx, -1);
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_precision(duk_context *ctx) {
-	/* The specification has quite awkward order of coercion and
-	 * checks for toPrecision().  The operations below are a bit
-	 * reordered, within constraints of observable side effects.
-	 */
-
-	duk_double_t d;
-	duk_small_int_t prec;
-	duk_small_int_t c;
-	duk_small_uint_t n2s_flags;
-
-	DUK_ASSERT_TOP(ctx, 1);
-
-	d = duk__push_this_number_plain(ctx);
-	if (duk_is_undefined(ctx, 0)) {
-		goto use_to_string;
-	}
-	DUK_ASSERT_TOP(ctx, 2);
-
-	duk_to_int(ctx, 0);  /* for side effects */
-
-	c = (duk_small_int_t) DUK_FPCLASSIFY(d);
-	if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
-		goto use_to_string;
-	}
-
-	prec = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 1, 21);
-
-	n2s_flags = DUK_N2S_FLAG_FIXED_FORMAT |
-	            DUK_N2S_FLAG_NO_ZERO_PAD;
-
-	duk_numconv_stringify(ctx,
-	                      10 /*radix*/,
-	                      prec /*digits*/,
-	                      n2s_flags /*flags*/);
-	return 1;
-
- use_to_string:
-	/* Used when precision is undefined; also used for NaN (-> "NaN"),
-	 * and +/- infinity (-> "Infinity", "-Infinity").
-	 */
-
-	DUK_ASSERT_TOP(ctx, 2);
-	duk_to_string(ctx, -1);
-	return 1;
-}

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_bi_object.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_object.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_object.c
deleted file mode 100644
index 28509ab..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_object.c
+++ /dev/null
@@ -1,577 +0,0 @@
-/*
- *  Object built-ins
- */
-
-#include "duk_internal.h"
-
-DUK_INTERNAL duk_ret_t duk_bi_object_constructor(duk_context *ctx) {
-	if (!duk_is_constructor_call(ctx) &&
-	    !duk_is_null_or_undefined(ctx, 0)) {
-		duk_to_object(ctx, 0);
-		return 1;
-	}
-
-	if (duk_is_object(ctx, 0)) {
-		return 1;
-	}
-
-	/* Pointer and buffer primitive values are treated like other
-	 * primitives values which have a fully fledged object counterpart:
-	 * promote to an object value.  Lightfuncs are coerced with
-	 * ToObject() even they could also be returned as is.
-	 */
-	if (duk_check_type_mask(ctx, 0, DUK_TYPE_MASK_STRING |
-	                                DUK_TYPE_MASK_BOOLEAN |
-	                                DUK_TYPE_MASK_NUMBER |
-	                                DUK_TYPE_MASK_POINTER |
-	                                DUK_TYPE_MASK_BUFFER |
-	                                DUK_TYPE_MASK_LIGHTFUNC)) {
-		duk_to_object(ctx, 0);
-		return 1;
-	}
-
-	duk_push_object_helper(ctx,
-	                       DUK_HOBJECT_FLAG_EXTENSIBLE |
-	                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-	                       DUK_BIDX_OBJECT_PROTOTYPE);
-	return 1;
-}
-
-/* Shared helper to implement Object.getPrototypeOf and the ES6
- * Object.prototype.__proto__ getter.
- *
- * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__
- */
-DUK_INTERNAL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hobject *h;
-	duk_hobject *proto;
-
-	DUK_UNREF(thr);
-
-	/* magic: 0=getter call, 1=Object.getPrototypeOf */
-	if (duk_get_current_magic(ctx) == 0) {
-		duk_push_this_coercible_to_object(ctx);
-		duk_insert(ctx, 0);
-	}
-
-	h = duk_require_hobject_or_lfunc(ctx, 0);
-	/* h is NULL for lightfunc */
-
-	/* XXX: should the API call handle this directly, i.e. attempt
-	 * to duk_push_hobject(ctx, null) would push a null instead?
-	 * (On the other hand 'undefined' would be just as logical, but
-	 * not wanted here.)
-	 */
-
-	if (h == NULL) {
-		duk_push_hobject_bidx(ctx, DUK_BIDX_FUNCTION_PROTOTYPE);
-	} else {
-		proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
-		if (proto) {
-			duk_push_hobject(ctx, proto);
-		} else {
-			duk_push_null(ctx);
-		}
-	}
-	return 1;
-}
-
-/* Shared helper to implement ES6 Object.setPrototypeOf and
- * Object.prototype.__proto__ setter.
- *
- * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-get-object.prototype.__proto__
- * http://www.ecma-international.org/ecma-262/6.0/index.html#sec-object.setprototypeof
- */
-DUK_INTERNAL duk_ret_t duk_bi_object_setprototype_shared(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hobject *h_obj;
-	duk_hobject *h_new_proto;
-	duk_hobject *h_curr;
-	duk_ret_t ret_success = 1;  /* retval for success path */
-
-	/* Preliminaries for __proto__ and setPrototypeOf (E6 19.1.2.18 steps 1-4);
-	 * magic: 0=setter call, 1=Object.setPrototypeOf
-	 */
-	if (duk_get_current_magic(ctx) == 0) {
-		duk_push_this_check_object_coercible(ctx);
-		duk_insert(ctx, 0);
-		if (!duk_check_type_mask(ctx, 1, DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_OBJECT)) {
-			return 0;
-		}
-
-		/* __proto__ setter returns 'undefined' on success unlike the
-		 * setPrototypeOf() call which returns the target object.
-		 */
-		ret_success = 0;
-	} else {
-		duk_require_object_coercible(ctx, 0);
-		duk_require_type_mask(ctx, 1, DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_OBJECT);
-	}
-
-	h_new_proto = duk_get_hobject(ctx, 1);
-	/* h_new_proto may be NULL */
-	if (duk_is_lightfunc(ctx, 0)) {
-		if (h_new_proto == thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]) {
-			goto skip;
-		}
-		goto fail_nonextensible;
-	}
-	h_obj = duk_get_hobject(ctx, 0);
-	if (!h_obj) {
-		goto skip;
-	}
-	DUK_ASSERT(h_obj != NULL);
-
-	/* [[SetPrototypeOf]] standard behavior, E6 9.1.2 */
-	/* TODO: implement Proxy object support here */
-
-	if (h_new_proto == DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_obj)) {
-		goto skip;
-	}
-	if (!DUK_HOBJECT_HAS_EXTENSIBLE(h_obj)) {
-		goto fail_nonextensible;
-	}
-	for (h_curr = h_new_proto; h_curr != NULL; h_curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_curr)) {
-		/* Loop prevention */
-		if (h_curr == h_obj) {
-			goto fail_loop;
-		}
-	}
-	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h_obj, h_new_proto);
-	/* fall thru */
-
- skip:
-	duk_set_top(ctx, 1);
-	return ret_success;
-
- fail_nonextensible:
- fail_loop:
-	return DUK_RET_TYPE_ERROR;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_constructor_get_own_property_descriptor(duk_context *ctx) {
-	/* XXX: no need for indirect call */
-	return duk_hobject_object_get_own_property_descriptor(ctx);
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_constructor_create(duk_context *ctx) {
-	duk_tval *tv;
-	duk_hobject *proto = NULL;
-
-	DUK_ASSERT_TOP(ctx, 2);
-
-	tv = duk_get_tval(ctx, 0);
-	DUK_ASSERT(tv != NULL);
-	if (DUK_TVAL_IS_NULL(tv)) {
-		;
-	} else if (DUK_TVAL_IS_OBJECT(tv)) {
-		proto = DUK_TVAL_GET_OBJECT(tv);
-		DUK_ASSERT(proto != NULL);
-	} else {
-		return DUK_RET_TYPE_ERROR;
-	}
-
-	(void) duk_push_object_helper_proto(ctx,
-	                                    DUK_HOBJECT_FLAG_EXTENSIBLE |
-	                                    DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-	                                    proto);
-
-	if (!duk_is_undefined(ctx, 1)) {
-		/* [ O Properties obj ] */
-
-		duk_replace(ctx, 0);
-
-		/* [ obj Properties ] */
-
-		/* Just call the "original" Object.defineProperties() to
-		 * finish up.
-		 */
-
-		return duk_bi_object_constructor_define_properties(ctx);
-	}
-
-	/* [ O Properties obj ] */
-
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_constructor_define_property(duk_context *ctx) {
-	duk_hobject *obj;
-	duk_hstring *key;
-	duk_hobject *get;
-	duk_hobject *set;
-	duk_idx_t idx_value;
-	duk_uint_t defprop_flags;
-
-	DUK_ASSERT(ctx != NULL);
-
-	DUK_DDD(DUK_DDDPRINT("Object.defineProperty(): ctx=%p obj=%!T key=%!T desc=%!T",
-	                     (void *) ctx,
-	                     (duk_tval *) duk_get_tval(ctx, 0),
-	                     (duk_tval *) duk_get_tval(ctx, 1),
-	                     (duk_tval *) duk_get_tval(ctx, 2)));
-
-	/* [ obj key desc ] */
-
-	/* Lightfuncs are currently supported by coercing to a temporary
-	 * Function object; changes will be allowed (the coerced value is
-	 * extensible) but will be lost.
-	 */
-	obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);
-	(void) duk_to_string(ctx, 1);
-	key = duk_require_hstring(ctx, 1);
-	(void) duk_require_hobject(ctx, 2);
-
-	DUK_ASSERT(obj != NULL);
-	DUK_ASSERT(key != NULL);
-	DUK_ASSERT(duk_get_hobject(ctx, 2) != NULL);
-
-	/*
-	 *  Validate and convert argument property descriptor (an Ecmascript
-	 *  object) into a set of defprop_flags and possibly property value,
-	 *  getter, and/or setter values on the value stack.
-	 *
-	 *  Lightfunc set/get values are coerced to full Functions.
-	 */
-
-	duk_hobject_prepare_property_descriptor(ctx,
-	                                        2 /*idx_desc*/,
-	                                        &defprop_flags,
-	                                        &idx_value,
-	                                        &get,
-	                                        &set);
-
-	/*
-	 *  Use Object.defineProperty() helper for the actual operation.
-	 */
-
-	duk_hobject_define_property_helper(ctx,
-	                                   defprop_flags,
-	                                   obj,
-	                                   key,
-	                                   idx_value,
-	                                   get,
-	                                   set);
-
-	/* Ignore the normalize/validate helper outputs on the value stack,
-	 * they're popped automatically.
-	 */
-
-	/*
-	 *  Return target object.
-	 */
-
-	duk_push_hobject(ctx, obj);
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_constructor_define_properties(duk_context *ctx) {
-	duk_small_uint_t pass;
-	duk_uint_t defprop_flags;
-	duk_hobject *obj;
-	duk_idx_t idx_value;
-	duk_hobject *get;
-	duk_hobject *set;
-
-	/* Lightfunc handling by ToObject() coercion. */
-	obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);  /* target */
-	DUK_ASSERT(obj != NULL);
-
-	duk_to_object(ctx, 1);        /* properties object */
-
-	DUK_DDD(DUK_DDDPRINT("target=%!iT, properties=%!iT",
-	                     (duk_tval *) duk_get_tval(ctx, 0),
-	                     (duk_tval *) duk_get_tval(ctx, 1)));
-
-	/*
-	 *  Two pass approach to processing the property descriptors.
-	 *  On first pass validate and normalize all descriptors before
-	 *  any changes are made to the target object.  On second pass
-	 *  make the actual modifications to the target object.
-	 *
-	 *  Right now we'll just use the same normalize/validate helper
-	 *  on both passes, ignoring its outputs on the first pass.
-	 */
-
-	for (pass = 0; pass < 2; pass++) {
-		duk_set_top(ctx, 2);  /* -> [ hobject props ] */
-		duk_enum(ctx, 1, DUK_ENUM_OWN_PROPERTIES_ONLY /*enum_flags*/);
-
-		for (;;) {
-			duk_hstring *key;
-
-			/* [ hobject props enum(props) ] */
-
-			duk_set_top(ctx, 3);
-
-			if (!duk_next(ctx, 2, 1 /*get_value*/)) {
-				break;
-			}
-
-			DUK_DDD(DUK_DDDPRINT("-> key=%!iT, desc=%!iT",
-			                     (duk_tval *) duk_get_tval(ctx, -2),
-			                     (duk_tval *) duk_get_tval(ctx, -1)));
-
-			/* [ hobject props enum(props) key desc ] */
-
-			duk_hobject_prepare_property_descriptor(ctx,
-			                                        4 /*idx_desc*/,
-			                                        &defprop_flags,
-			                                        &idx_value,
-			                                        &get,
-			                                        &set);
-
-			/* [ hobject props enum(props) key desc value? getter? setter? ] */
-
-			if (pass == 0) {
-				continue;
-			}
-
-			key = duk_get_hstring(ctx, 3);
-			DUK_ASSERT(key != NULL);
-
-			duk_hobject_define_property_helper(ctx,
-			                                   defprop_flags,
-			                                   obj,
-			                                   key,
-			                                   idx_value,
-			                                   get,
-			                                   set);
-		}
-	}
-
-	/*
-	 *  Return target object
-	 */
-
-	duk_dup(ctx, 0);
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_constructor_seal_freeze_shared(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hobject *h;
-	duk_bool_t is_freeze;
-
-	h = duk_require_hobject_or_lfunc(ctx, 0);
-	if (!h) {
-		/* Lightfunc, always success. */
-		return 1;
-	}
-
-	is_freeze = (duk_bool_t) duk_get_current_magic(ctx);
-	duk_hobject_object_seal_freeze_helper(thr, h, is_freeze);
-
-	/* Sealed and frozen objects cannot gain any more properties,
-	 * so this is a good time to compact them.
-	 */
-	duk_hobject_compact_props(thr, h);
-
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_constructor_prevent_extensions(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hobject *h;
-
-	h = duk_require_hobject_or_lfunc(ctx, 0);
-	if (!h) {
-		/* Lightfunc, always success. */
-		return 1;
-	}
-	DUK_ASSERT(h != NULL);
-
-	DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
-
-	/* A non-extensible object cannot gain any more properties,
-	 * so this is a good time to compact.
-	 */
-	duk_hobject_compact_props(thr, h);
-
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_sealed_frozen_shared(duk_context *ctx) {
-	duk_hobject *h;
-	duk_bool_t is_frozen;
-	duk_bool_t rc;
-
-	h = duk_require_hobject_or_lfunc(ctx, 0);
-	if (!h) {
-		duk_push_true(ctx);  /* frozen and sealed */
-	} else {
-		is_frozen = duk_get_current_magic(ctx);
-		rc = duk_hobject_object_is_sealed_frozen_helper((duk_hthread *) ctx, h, is_frozen /*is_frozen*/);
-		duk_push_boolean(ctx, rc);
-	}
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_extensible(duk_context *ctx) {
-	duk_hobject *h;
-
-	h = duk_require_hobject_or_lfunc(ctx, 0);
-	if (!h) {
-		duk_push_false(ctx);
-	} else {
-		duk_push_boolean(ctx, DUK_HOBJECT_HAS_EXTENSIBLE(h));
-	}
-	return 1;
-}
-
-/* Shared helper for Object.getOwnPropertyNames() and Object.keys().
- * Magic: 0=getOwnPropertyNames, 1=Object.keys.
- */
-DUK_INTERNAL duk_ret_t duk_bi_object_constructor_keys_shared(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hobject *obj;
-#if defined(DUK_USE_ES6_PROXY)
-	duk_hobject *h_proxy_target;
-	duk_hobject *h_proxy_handler;
-	duk_hobject *h_trap_result;
-	duk_uarridx_t i, len, idx;
-#endif
-	duk_small_uint_t enum_flags;
-
-	DUK_ASSERT_TOP(ctx, 1);
-	DUK_UNREF(thr);
-
-	obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);
-	DUK_ASSERT(obj != NULL);
-	DUK_UNREF(obj);
-
-#if defined(DUK_USE_ES6_PROXY)
-	if (DUK_LIKELY(!duk_hobject_proxy_check(thr,
-	                                        obj,
-	                                        &h_proxy_target,
-	                                        &h_proxy_handler))) {
-		goto skip_proxy;
-	}
-
-	duk_push_hobject(ctx, h_proxy_handler);
-	if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_OWN_KEYS)) {
-		/* Careful with reachability here: don't pop 'obj' before pushing
-		 * proxy target.
-		 */
-		DUK_DDD(DUK_DDDPRINT("no ownKeys trap, get keys of target instead"));
-		duk_pop_2(ctx);
-		duk_push_hobject(ctx, h_proxy_target);
-		duk_replace(ctx, 0);
-		DUK_ASSERT_TOP(ctx, 1);
-		goto skip_proxy;
-	}
-
-	/* [ obj handler trap ] */
-	duk_insert(ctx, -2);
-	duk_push_hobject(ctx, h_proxy_target);  /* -> [ obj trap handler target ] */
-	duk_call_method(ctx, 1 /*nargs*/);      /* -> [ obj trap_result ] */
-	h_trap_result = duk_require_hobject(ctx, -1);
-	DUK_UNREF(h_trap_result);
-
-	len = (duk_uarridx_t) duk_get_length(ctx, -1);
-	idx = 0;
-	duk_push_array(ctx);
-	for (i = 0; i < len; i++) {
-		/* [ obj trap_result res_arr ] */
-		if (duk_get_prop_index(ctx, -2, i) && duk_is_string(ctx, -1)) {
-			/* XXX: for Object.keys() we should check enumerability of key */
-			/* [ obj trap_result res_arr propname ] */
-			duk_put_prop_index(ctx, -2, idx);
-			idx++;
-		} else {
-			duk_pop(ctx);
-		}
-	}
-
-	/* XXX: missing trap result validation for non-configurable target keys
-	 * (must be present), for non-extensible target all target keys must be
-	 * present and no extra keys can be present.
-	 * http://www.ecma-international.org/ecma-262/6.0/#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys
-	 */
-
-	/* XXX: for Object.keys() the [[OwnPropertyKeys]] result (trap result)
-	 * should be filtered so that only enumerable keys remain.  Enumerability
-	 * should be checked with [[GetOwnProperty]] on the original object
-	 * (i.e., the proxy in this case).  If the proxy has a getOwnPropertyDescriptor
-	 * trap, it should be triggered for every property.  If the proxy doesn't have
-	 * the trap, enumerability should be checked against the target object instead.
-	 * We don't do any of this now, so Object.keys() and Object.getOwnPropertyNames()
-	 * return the same result now for proxy traps.  We still do clean up the trap
-	 * result, so that Object.keys() and Object.getOwnPropertyNames() will return a
-	 * clean array of strings without gaps.
-	 */
-	return 1;
-
- skip_proxy:
-#endif  /* DUK_USE_ES6_PROXY */
-
-	DUK_ASSERT_TOP(ctx, 1);
-
-	if (duk_get_current_magic(ctx)) {
-		/* Object.keys */
-		enum_flags = DUK_ENUM_OWN_PROPERTIES_ONLY |
-		             DUK_ENUM_NO_PROXY_BEHAVIOR;
-	} else {
-		/* Object.getOwnPropertyNames */
-		enum_flags = DUK_ENUM_INCLUDE_NONENUMERABLE |
-		             DUK_ENUM_OWN_PROPERTIES_ONLY |
-		             DUK_ENUM_NO_PROXY_BEHAVIOR;
-	}
-
-	return duk_hobject_get_enumerated_keys(ctx, enum_flags);
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_string(duk_context *ctx) {
-	duk_push_this(ctx);
-	duk_to_object_class_string_top(ctx);
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_locale_string(duk_context *ctx) {
-	DUK_ASSERT_TOP(ctx, 0);
-	(void) duk_push_this_coercible_to_object(ctx);
-	duk_get_prop_stridx(ctx, 0, DUK_STRIDX_TO_STRING);
-	if (!duk_is_callable(ctx, 1)) {
-		return DUK_RET_TYPE_ERROR;
-	}
-	duk_dup(ctx, 0);  /* -> [ O toString O ] */
-	duk_call_method(ctx, 0);  /* XXX: call method tail call? */
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_prototype_value_of(duk_context *ctx) {
-	(void) duk_push_this_coercible_to_object(ctx);
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hobject *h_v;
-	duk_hobject *h_obj;
-
-	DUK_ASSERT_TOP(ctx, 1);
-
-	h_v = duk_get_hobject(ctx, 0);
-	if (!h_v) {
-		duk_push_false(ctx);  /* XXX: tail call: return duk_push_false(ctx) */
-		return 1;
-	}
-
-	h_obj = duk_push_this_coercible_to_object(ctx);
-	DUK_ASSERT(h_obj != NULL);
-
-	/* E5.1 Section 15.2.4.6, step 3.a, lookup proto once before compare.
-	 * Prototype loops should cause an error to be thrown.
-	 */
-	duk_push_boolean(ctx, duk_hobject_prototype_chain_contains(thr, DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_v), h_obj, 0 /*ignore_loop*/));
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_prototype_has_own_property(duk_context *ctx) {
-	return duk_hobject_object_ownprop_helper(ctx, 0 /*required_desc_flags*/);
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_object_prototype_property_is_enumerable(duk_context *ctx) {
-	return duk_hobject_object_ownprop_helper(ctx, DUK_PROPDESC_FLAG_ENUMERABLE /*required_desc_flags*/);
-}

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_bi_pointer.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_pointer.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_pointer.c
deleted file mode 100644
index 340fbae..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_pointer.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- *  Pointer built-ins
- */
-
-#include "duk_internal.h"
-
-/*
- *  Constructor
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_pointer_constructor(duk_context *ctx) {
-	/* XXX: this behavior is quite useless now; it would be nice to be able
-	 * to create pointer values from e.g. numbers or strings.  Numbers are
-	 * problematic on 64-bit platforms though.  Hex encoded strings?
-	 */
-	if (duk_get_top(ctx) == 0) {
-		duk_push_pointer(ctx, NULL);
-	} else {
-		duk_to_pointer(ctx, 0);
-	}
-	DUK_ASSERT(duk_is_pointer(ctx, 0));
-	duk_set_top(ctx, 1);
-
-	if (duk_is_constructor_call(ctx)) {
-		duk_push_object_helper(ctx,
-		                       DUK_HOBJECT_FLAG_EXTENSIBLE |
-		                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_POINTER),
-		                       DUK_BIDX_POINTER_PROTOTYPE);
-
-		/* Pointer 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;
-}
-
-/*
- *  toString(), valueOf()
- */
-
-DUK_INTERNAL duk_ret_t duk_bi_pointer_prototype_tostring_shared(duk_context *ctx) {
-	duk_tval *tv;
-	duk_small_int_t to_string = duk_get_current_magic(ctx);
-
-	duk_push_this(ctx);
-	tv = duk_require_tval(ctx, -1);
-	DUK_ASSERT(tv != NULL);
-
-	if (DUK_TVAL_IS_POINTER(tv)) {
-		/* nop */
-	} else if (DUK_TVAL_IS_OBJECT(tv)) {
-		duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
-		DUK_ASSERT(h != NULL);
-
-		/* Must be a "pointer object", i.e. class "Pointer" */
-		if (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_POINTER) {
-			goto type_error;
-		}
-
-		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
-	} else {
-		goto type_error;
-	}
-
-	if (to_string) {
-		duk_to_string(ctx, -1);
-	}
-	return 1;
-
- type_error:
-	return DUK_RET_TYPE_ERROR;
-}

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_bi_protos.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_protos.h b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_protos.h
deleted file mode 100644
index f9b42bc..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_protos.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- *  Prototypes for built-in functions not automatically covered by the
- *  header declarations emitted by genbuiltins.py.
- */
-
-#ifndef DUK_BUILTIN_PROTOS_H_INCLUDED
-#define DUK_BUILTIN_PROTOS_H_INCLUDED
-
-/* Buffer size needed for duk_bi_date_format_timeval().
- * Accurate value is 32 + 1 for NUL termination:
- *   >>> len('+123456-01-23T12:34:56.123+12:34')
- *   32
- * Include additional space to be safe.
- */
-#define  DUK_BI_DATE_ISO8601_BUFSIZE  48
-
-/* Maximum length of CommonJS module identifier to resolve.  Length includes
- * both current module ID, requested (possibly relative) module ID, and a
- * slash in between.
- */
-#define  DUK_BI_COMMONJS_MODULE_ID_LIMIT  256
-
-/* Helpers exposed for internal use */
-DUK_INTERNAL_DECL void duk_bi_date_timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags);
-DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags);
-DUK_INTERNAL_DECL void duk_bi_date_format_timeval(duk_double_t timeval, duk_uint8_t *out_buf);
-DUK_INTERNAL_DECL duk_bool_t duk_bi_date_is_leap_year(duk_int_t year);
-DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_valid_range(duk_double_t x);
-DUK_INTERNAL_DECL duk_bool_t duk_bi_date_year_in_valid_range(duk_double_t year);
-DUK_INTERNAL_DECL duk_bool_t duk_bi_date_timeval_in_leeway_range(duk_double_t x);
-/* Built-in providers */
-#if defined(DUK_USE_DATE_NOW_GETTIMEOFDAY)
-DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_gettimeofday(duk_context *ctx);
-#endif
-#if defined(DUK_USE_DATE_NOW_TIME)
-DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_time(duk_context *ctx);
-#endif
-#if defined(DUK_USE_DATE_NOW_WINDOWS)
-DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now_windows(duk_context *ctx);
-#endif
-#if defined(DUK_USE_DATE_TZO_GMTIME_R) || defined(DUK_USE_DATE_TZO_GMTIME)
-DUK_INTERNAL_DECL duk_int_t duk_bi_date_get_local_tzoffset_gmtime(duk_double_t d);
-#endif
-#if defined(DUK_USE_DATE_TZO_WINDOWS)
-DUK_INTERNAL_DECL duk_int_t duk_bi_date_get_local_tzoffset_windows(duk_double_t d);
-#endif
-#if defined(DUK_USE_DATE_PRS_STRPTIME)
-DUK_INTERNAL_DECL duk_bool_t duk_bi_date_parse_string_strptime(duk_context *ctx, const char *str);
-#endif
-#if defined(DUK_USE_DATE_PRS_GETDATE)
-DUK_INTERNAL_DECL duk_bool_t duk_bi_date_parse_string_getdate(duk_context *ctx, const char *str);
-#endif
-#if defined(DUK_USE_DATE_FMT_STRFTIME)
-DUK_INTERNAL_DECL duk_bool_t duk_bi_date_format_parts_strftime(duk_context *ctx, duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags);
-#endif
-
-DUK_INTERNAL_DECL
-void duk_bi_json_parse_helper(duk_context *ctx,
-                              duk_idx_t idx_value,
-                              duk_idx_t idx_reviver,
-                              duk_small_uint_t flags);
-DUK_INTERNAL_DECL
-void duk_bi_json_stringify_helper(duk_context *ctx,
-                                  duk_idx_t idx_value,
-                                  duk_idx_t idx_replacer,
-                                  duk_idx_t idx_space,
-                                  duk_small_uint_t flags);
-
-#endif  /* DUK_BUILTIN_PROTOS_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_bi_proxy.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_proxy.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_proxy.c
deleted file mode 100644
index 9787ec4..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_proxy.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- *  Proxy built-in (ES6)
- */
-
-#include "duk_internal.h"
-
-#if defined(DUK_USE_ES6_PROXY)
-DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx) {
-	duk_hobject *h_target;
-	duk_hobject *h_handler;
-
-	if (!duk_is_constructor_call(ctx)) {
-		return DUK_RET_TYPE_ERROR;
-	}
-
-	/* Reject a proxy object as the target because it would need
-	 * special handler in property lookups.  (ES6 has no such restriction)
-	 */
-	h_target = duk_require_hobject_or_lfunc_coerce(ctx, 0);
-	DUK_ASSERT(h_target != NULL);
-	if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_target)) {
-		return DUK_RET_TYPE_ERROR;
-	}
-
-	/* Reject a proxy object as the handler because it would cause
-	 * potentially unbounded recursion.  (ES6 has no such restriction)
-	 */
-	h_handler = duk_require_hobject_or_lfunc_coerce(ctx, 1);
-	DUK_ASSERT(h_handler != NULL);
-	if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_handler)) {
-		return DUK_RET_TYPE_ERROR;
-	}
-
-	/* XXX: the returned value is exotic in ES6, but we use a
-	 * simple object here with no prototype.  Without a prototype,
-	 * [[DefaultValue]] coercion fails which is abit confusing.
-	 * No callable check/handling in the current Proxy subset.
-	 */
-	(void) duk_push_object_helper_proto(ctx,
-	                                    DUK_HOBJECT_FLAG_EXTENSIBLE |
-	                                    DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ |
-	                                    DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-	                                    NULL);
-	DUK_ASSERT_TOP(ctx, 3);
-
-	/* Make _Target and _Handler non-configurable and non-writable.
-	 * They can still be forcibly changed by C code (both user and
-	 * Duktape internal), but not by Ecmascript code.
-	 */
-
-	/* Proxy target */
-	duk_dup(ctx, 0);
-	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE);
-
-	/* Proxy handler */
-	duk_dup(ctx, 1);
-	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_HANDLER, DUK_PROPDESC_FLAGS_NONE);
-
-	return 1;  /* replacement handler */
-}
-#else  /* DUK_USE_ES6_PROXY */
-DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNSUPPORTED_ERROR;
-}
-#endif  /* DUK_USE_ES6_PROXY */

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_bi_regexp.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_regexp.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_regexp.c
deleted file mode 100644
index 2259c77..0000000
--- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_bi_regexp.c
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- *  RegExp built-ins
- */
-
-#include "duk_internal.h"
-
-#ifdef DUK_USE_REGEXP_SUPPORT
-
-DUK_LOCAL void duk__get_this_regexp(duk_context *ctx) {
-	duk_hobject *h;
-
-	duk_push_this(ctx);
-	h = duk_require_hobject_with_class(ctx, -1, DUK_HOBJECT_CLASS_REGEXP);
-	DUK_ASSERT(h != NULL);
-	DUK_UNREF(h);
-	duk_insert(ctx, 0);  /* prepend regexp to valstack 0 index */
-}
-
-/* XXX: much to improve (code size) */
-DUK_INTERNAL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx) {
-	duk_hthread *thr = (duk_hthread *) ctx;
-	duk_hobject *h_pattern;
-
-	DUK_ASSERT_TOP(ctx, 2);
-	h_pattern = duk_get_hobject(ctx, 0);
-
-	if (!duk_is_constructor_call(ctx) &&
-	    h_pattern != NULL &&
-	    DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP &&
-	    duk_is_undefined(ctx, 1)) {
-		/* Called as a function, pattern has [[Class]] "RegExp" and
-		 * flags is undefined -> return object as is.
-		 */
-		duk_dup(ctx, 0);
-		return 1;
-	}
-
-	/* Else functionality is identical for function call and constructor
-	 * call.
-	 */
-
-	if (h_pattern != NULL &&
-	    DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP) {
-		if (duk_is_undefined(ctx, 1)) {
-			duk_bool_t flag_g, flag_i, flag_m;
-			duk_get_prop_stridx(ctx, 0, DUK_STRIDX_SOURCE);
-			flag_g = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
-			flag_i = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_IGNORE_CASE, NULL);
-			flag_m = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_MULTILINE, NULL);
-
-			duk_push_sprintf(ctx, "%s%s%s",
-			                 (const char *) (flag_g ? "g" : ""),
-			                 (const char *) (flag_i ? "i" : ""),
-			                 (const char *) (flag_m ? "m" : ""));
-
-			/* [ ... pattern flags ] */
-		} else {
-			return DUK_RET_TYPE_ERROR;
-		}
-	} else {
-		if (duk_is_undefined(ctx, 0)) {
-			duk_push_string(ctx, "");
-		} else {
-			duk_dup(ctx, 0);
-			duk_to_string(ctx, -1);
-		}
-		if (duk_is_undefined(ctx, 1)) {
-			duk_push_string(ctx, "");
-		} else {
-			duk_dup(ctx, 1);
-			duk_to_string(ctx, -1);
-		}
-
-		/* [ ... pattern flags ] */
-	}
-
-	DUK_DDD(DUK_DDDPRINT("RegExp constructor/function call, pattern=%!T, flags=%!T",
-	                     (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
-
-	/* [ ... pattern flags ] */
-
-	duk_regexp_compile(thr);
-
-	/* [ ... bytecode escaped_source ] */
-
-	duk_regexp_create_instance(thr);
-
-	/* [ ... RegExp ] */
-
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_exec(duk_context *ctx) {
-	duk__get_this_regexp(ctx);
-
-	/* [ regexp input ] */
-
-	duk_regexp_match((duk_hthread *) ctx);
-
-	/* [ result ] */
-
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_test(duk_context *ctx) {
-	duk__get_this_regexp(ctx);
-
-	/* [ regexp input ] */
-
-	/* result object is created and discarded; wasteful but saves code space */
-	duk_regexp_match((duk_hthread *) ctx);
-
-	/* [ result ] */
-
-	duk_push_boolean(ctx, (duk_is_null(ctx, -1) ? 0 : 1));
-
-	return 1;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_to_string(duk_context *ctx) {
-	duk_hstring *h_bc;
-	duk_small_int_t re_flags;
-
-#if 0
-	/* A little tricky string approach to provide the flags string.
-	 * This depends on the specific flag values in duk_regexp.h,
-	 * which needs to be asserted for.  In practice this doesn't
-	 * produce more compact code than the easier approach in use.
-	 */
-
-	const char *flag_strings = "gim\0gi\0gm\0g\0";
-	duk_uint8_t flag_offsets[8] = {
-		(duk_uint8_t) 3,   /* flags: ""    */
-		(duk_uint8_t) 10,  /* flags: "g"   */
-		(duk_uint8_t) 5,   /* flags: "i"   */
-		(duk_uint8_t) 4,   /* flags: "gi"  */
-		(duk_uint8_t) 2,   /* flags: "m"   */
-		(duk_uint8_t) 7,   /* flags: "gm"  */
-		(duk_uint8_t) 1,   /* flags: "im"  */
-		(duk_uint8_t) 0,   /* flags: "gim" */
-	};
-	DUK_ASSERT(DUK_RE_FLAG_GLOBAL == 1);
-	DUK_ASSERT(DUK_RE_FLAG_IGNORE_CASE == 2);
-	DUK_ASSERT(DUK_RE_FLAG_MULTILINE == 4);
-#endif
-
-	duk__get_this_regexp(ctx);
-
-	/* [ regexp ] */
-
-	duk_get_prop_stridx(ctx, 0, DUK_STRIDX_SOURCE);
-	duk_get_prop_stridx(ctx, 0, DUK_STRIDX_INT_BYTECODE);
-	h_bc = duk_get_hstring(ctx, -1);
-	DUK_ASSERT(h_bc != NULL);
-	DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(h_bc) >= 1);
-	DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h_bc) >= 1);
-	DUK_ASSERT(DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80);
-	re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0];
-
-	/* [ regexp source bytecode ] */
-
-#if 1
-	/* This is a cleaner approach and also produces smaller code than
-	 * the other alternative.  Use duk_require_string() for format
-	 * safety (although the source property should always exist).
-	 */
-	duk_push_sprintf(ctx, "/%s/%s%s%s",
-	                 (const char *) duk_require_string(ctx, -2),  /* require to be safe */
-	                 (re_flags & DUK_RE_FLAG_GLOBAL) ? "g" : "",
-	                 (re_flags & DUK_RE_FLAG_IGNORE_CASE) ? "i" : "",
-	                 (re_flags & DUK_RE_FLAG_MULTILINE) ? "m" : "");
-#else
-	/* This should not be necessary because no-one should tamper with the
-	 * regexp bytecode, but is prudent to avoid potential segfaults if that
-	 * were to happen for some reason.
-	 */
-	re_flags &= 0x07;
-	DUK_ASSERT(re_flags >= 0 && re_flags <= 7);  /* three flags */
-	duk_push_sprintf(ctx, "/%s/%s",
-	                 (const char *) duk_require_string(ctx, -2),
-	                 (const char *) (flag_strings + flag_offsets[re_flags]));
-#endif
-
-	return 1;
-}
-
-#else  /* DUK_USE_REGEXP_SUPPORT */
-
-DUK_INTERNAL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNSUPPORTED_ERROR;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_exec(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNSUPPORTED_ERROR;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_test(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNSUPPORTED_ERROR;
-}
-
-DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_to_string(duk_context *ctx) {
-	DUK_UNREF(ctx);
-	return DUK_RET_UNSUPPORTED_ERROR;
-}
-
-#endif  /* DUK_USE_REGEXP_SUPPORT */