nifi-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ald...@apache.org
Subject [19/52] [partial] nifi-minifi-cpp git commit: Remove libxml2, civetweb thirdparty.
Date Thu, 04 May 2017 19:06:27 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_debugger.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_debugger.h b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_debugger.h
deleted file mode 100644
index f79557b..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_debugger.h
+++ /dev/null
@@ -1,144 +0,0 @@
-#ifndef DUK_DEBUGGER_H_INCLUDED
-#define DUK_DEBUGGER_H_INCLUDED
-
-/* Debugger protocol version is defined in the public API header. */
-
-/* Initial bytes for markers. */
-#define DUK_DBG_IB_EOM                   0x00
-#define DUK_DBG_IB_REQUEST               0x01
-#define DUK_DBG_IB_REPLY                 0x02
-#define DUK_DBG_IB_ERROR                 0x03
-#define DUK_DBG_IB_NOTIFY                0x04
-
-/* Other initial bytes. */
-#define DUK_DBG_IB_INT4                  0x10
-#define DUK_DBG_IB_STR4                  0x11
-#define DUK_DBG_IB_STR2                  0x12
-#define DUK_DBG_IB_BUF4                  0x13
-#define DUK_DBG_IB_BUF2                  0x14
-#define DUK_DBG_IB_UNUSED                0x15
-#define DUK_DBG_IB_UNDEFINED             0x16
-#define DUK_DBG_IB_NULL                  0x17
-#define DUK_DBG_IB_TRUE                  0x18
-#define DUK_DBG_IB_FALSE                 0x19
-#define DUK_DBG_IB_NUMBER                0x1a
-#define DUK_DBG_IB_OBJECT                0x1b
-#define DUK_DBG_IB_POINTER               0x1c
-#define DUK_DBG_IB_LIGHTFUNC             0x1d
-#define DUK_DBG_IB_HEAPPTR               0x1e
-/* The short string/integer initial bytes starting from 0x60 don't have
- * defines now.
- */
-
-/* Error codes. */
-#define DUK_DBG_ERR_UNKNOWN              0x00
-#define DUK_DBG_ERR_UNSUPPORTED          0x01
-#define DUK_DBG_ERR_TOOMANY              0x02
-#define DUK_DBG_ERR_NOTFOUND             0x03
-#define DUK_DBG_ERR_APPLICATION          0x04
-
-/* Commands and notifys initiated by Duktape. */
-#define DUK_DBG_CMD_STATUS               0x01
-#define DUK_DBG_CMD_PRINT                0x02
-#define DUK_DBG_CMD_ALERT                0x03
-#define DUK_DBG_CMD_LOG                  0x04
-#define DUK_DBG_CMD_THROW                0x05
-#define DUK_DBG_CMD_DETACHING            0x06
-#define DUK_DBG_CMD_APPNOTIFY            0x07
-
-/* Commands initiated by debug client. */
-#define DUK_DBG_CMD_BASICINFO            0x10
-#define DUK_DBG_CMD_TRIGGERSTATUS        0x11
-#define DUK_DBG_CMD_PAUSE                0x12
-#define DUK_DBG_CMD_RESUME               0x13
-#define DUK_DBG_CMD_STEPINTO             0x14
-#define DUK_DBG_CMD_STEPOVER             0x15
-#define DUK_DBG_CMD_STEPOUT              0x16
-#define DUK_DBG_CMD_LISTBREAK            0x17
-#define DUK_DBG_CMD_ADDBREAK             0x18
-#define DUK_DBG_CMD_DELBREAK             0x19
-#define DUK_DBG_CMD_GETVAR               0x1a
-#define DUK_DBG_CMD_PUTVAR               0x1b
-#define DUK_DBG_CMD_GETCALLSTACK         0x1c
-#define DUK_DBG_CMD_GETLOCALS            0x1d
-#define DUK_DBG_CMD_EVAL                 0x1e
-#define DUK_DBG_CMD_DETACH               0x1f
-#define DUK_DBG_CMD_DUMPHEAP             0x20
-#define DUK_DBG_CMD_GETBYTECODE          0x21
-#define DUK_DBG_CMD_APPREQUEST           0x22
-#define DUK_DBG_CMD_GETHEAPOBJINFO       0x23
-#define DUK_DBG_CMD_GETOBJPROPDESC       0x24
-#define DUK_DBG_CMD_GETOBJPROPDESCRANGE  0x25
-
-/* The low 8 bits map directly to duk_hobject.h DUK_PROPDESC_FLAG_xxx.
- * The remaining flags are specific to the debugger.
- */
-#define DUK_DBG_PROPFLAG_INTERNAL        (1 << 8)
-
-#if defined(DUK_USE_DEBUGGER_SUPPORT)
-DUK_INTERNAL_DECL void duk_debug_do_detach(duk_heap *heap);
-
-DUK_INTERNAL_DECL duk_bool_t duk_debug_read_peek(duk_hthread *thr);
-DUK_INTERNAL_DECL void duk_debug_write_flush(duk_hthread *thr);
-
-DUK_INTERNAL_DECL void duk_debug_skip_bytes(duk_hthread *thr, duk_size_t length);
-DUK_INTERNAL_DECL void duk_debug_skip_byte(duk_hthread *thr);
-
-DUK_INTERNAL_DECL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_size_t length);
-DUK_INTERNAL_DECL duk_uint8_t duk_debug_read_byte(duk_hthread *thr);
-DUK_INTERNAL_DECL duk_int32_t duk_debug_read_int(duk_hthread *thr);
-DUK_INTERNAL_DECL duk_hstring *duk_debug_read_hstring(duk_hthread *thr);
-/* XXX: exposed duk_debug_read_pointer */
-/* XXX: exposed duk_debug_read_buffer */
-/* XXX: exposed duk_debug_read_hbuffer */
-#if 0
-DUK_INTERNAL_DECL duk_heaphdr *duk_debug_read_heapptr(duk_hthread *thr);
-#endif
-#if defined(DUK_USE_DEBUGGER_INSPECT)
-DUK_INTERNAL_DECL duk_heaphdr *duk_debug_read_any_ptr(duk_hthread *thr);
-#endif
-DUK_INTERNAL_DECL duk_tval *duk_debug_read_tval(duk_hthread *thr);
-
-DUK_INTERNAL_DECL void duk_debug_write_bytes(duk_hthread *thr, const duk_uint8_t *data, duk_size_t length);
-DUK_INTERNAL_DECL void duk_debug_write_byte(duk_hthread *thr, duk_uint8_t x);
-DUK_INTERNAL_DECL void duk_debug_write_unused(duk_hthread *thr);
-DUK_INTERNAL_DECL void duk_debug_write_undefined(duk_hthread *thr);
-#if defined(DUK_USE_DEBUGGER_INSPECT)
-DUK_INTERNAL_DECL void duk_debug_write_null(duk_hthread *thr);
-#endif
-DUK_INTERNAL_DECL void duk_debug_write_boolean(duk_hthread *thr, duk_uint_t val);
-DUK_INTERNAL_DECL void duk_debug_write_int(duk_hthread *thr, duk_int32_t x);
-DUK_INTERNAL_DECL void duk_debug_write_uint(duk_hthread *thr, duk_uint32_t x);
-DUK_INTERNAL_DECL void duk_debug_write_string(duk_hthread *thr, const char *data, duk_size_t length);
-DUK_INTERNAL_DECL void duk_debug_write_cstring(duk_hthread *thr, const char *data);
-DUK_INTERNAL_DECL void duk_debug_write_hstring(duk_hthread *thr, duk_hstring *h);
-DUK_INTERNAL_DECL void duk_debug_write_buffer(duk_hthread *thr, const char *data, duk_size_t length);
-DUK_INTERNAL_DECL void duk_debug_write_hbuffer(duk_hthread *thr, duk_hbuffer *h);
-DUK_INTERNAL_DECL void duk_debug_write_pointer(duk_hthread *thr, void *ptr);
-#if defined(DUK_USE_DEBUGGER_DUMPHEAP) || defined(DUK_USE_DEBUGGER_INSPECT)
-DUK_INTERNAL_DECL void duk_debug_write_heapptr(duk_hthread *thr, duk_heaphdr *h);
-#endif
-DUK_INTERNAL_DECL void duk_debug_write_hobject(duk_hthread *thr, duk_hobject *obj);
-DUK_INTERNAL_DECL void duk_debug_write_tval(duk_hthread *thr, duk_tval *tv);
-#if 0  /* unused */
-DUK_INTERNAL_DECL void duk_debug_write_request(duk_hthread *thr, duk_small_uint_t command);
-#endif
-DUK_INTERNAL_DECL void duk_debug_write_reply(duk_hthread *thr);
-DUK_INTERNAL_DECL void duk_debug_write_error_eom(duk_hthread *thr, duk_small_uint_t err_code, const char *msg);
-DUK_INTERNAL_DECL void duk_debug_write_notify(duk_hthread *thr, duk_small_uint_t command);
-DUK_INTERNAL_DECL void duk_debug_write_eom(duk_hthread *thr);
-
-DUK_INTERNAL_DECL duk_uint_fast32_t duk_debug_curr_line(duk_hthread *thr);
-DUK_INTERNAL_DECL void duk_debug_send_status(duk_hthread *thr);
-#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY)
-DUK_INTERNAL_DECL void duk_debug_send_throw(duk_hthread *thr, duk_bool_t fatal);
-#endif
-
-DUK_INTERNAL_DECL void duk_debug_halt_execution(duk_hthread *thr, duk_bool_t use_prev_pc);
-DUK_INTERNAL_DECL duk_bool_t duk_debug_process_messages(duk_hthread *thr, duk_bool_t no_block);
-
-DUK_INTERNAL_DECL duk_small_int_t duk_debug_add_breakpoint(duk_hthread *thr, duk_hstring *filename, duk_uint32_t line);
-DUK_INTERNAL_DECL duk_bool_t duk_debug_remove_breakpoint(duk_hthread *thr, duk_small_uint_t breakpoint_index);
-#endif
-
-#endif  /* DUK_DEBUGGER_H_INCLUDED */

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_error.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error.h b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error.h
deleted file mode 100644
index 2b00a78..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error.h
+++ /dev/null
@@ -1,439 +0,0 @@
-/*
- *  Error handling macros, assertion macro, error codes.
- *
- *  There are three level of 'errors':
- *
- *    1. Ordinary errors, relative to a thread, cause a longjmp, catchable.
- *    2. Fatal errors, relative to a heap, cause fatal handler to be called.
- *    3. Panic errors, unrelated to a heap and cause a process exit.
- *
- *  Panics are used by the default fatal error handler and by debug code
- *  such as assertions.  By providing a proper fatal error handler, user
- *  code can avoid panics in non-debug builds.
- */
-
-#ifndef DUK_ERROR_H_INCLUDED
-#define DUK_ERROR_H_INCLUDED
-
-/*
- *  Error codes: defined in duktape.h
- *
- *  Error codes are used as a shorthand to throw exceptions from inside
- *  the implementation.  The appropriate Ecmascript object is constructed
- *  based on the code.  Ecmascript code throws objects directly.  The error
- *  codes are defined in the public API header because they are also used
- *  by calling code.
- */
-
-/*
- *  Normal error
- *
- *  Normal error is thrown with a longjmp() through the current setjmp()
- *  catchpoint record in the duk_heap.  The 'curr_thread' of the duk_heap
- *  identifies the throwing thread.
- *
- *  Error formatting is usually unnecessary.  The error macros provide a
- *  zero argument version (no formatting) and separate macros for small
- *  argument counts.  Variadic macros are not used to avoid portability
- *  issues and avoid the need for stash-based workarounds when they're not
- *  available.  Vararg calls are avoided for non-formatted error calls
- *  because vararg call sites are larger than normal, and there are a lot
- *  of call sites with no formatting.
- *
- *  Note that special formatting provided by debug macros is NOT available.
- *
- *  The _RAW variants allow the caller to specify file and line.  This makes
- *  it easier to write checked calls which want to use the call site of the
- *  checked function, not the error macro call inside the checked function.
- */
-
-#if defined(DUK_USE_VERBOSE_ERRORS)
-
-/* Because there are quite many call sites, pack error code (require at most
- * 8-bit) into a single argument.
- */
-#define DUK_ERROR(thr,err,msg) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
-	} while (0)
-#define DUK_ERROR_RAW(thr,file,line,err,msg) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
-	} while (0)
-
-#define DUK_ERROR_FMT1(thr,err,fmt,arg1) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
-	} while (0)
-#define DUK_ERROR_RAW_FMT1(thr,file,line,err,fmt,arg1) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
-	} while (0)
-
-#define DUK_ERROR_FMT2(thr,err,fmt,arg1,arg2) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
-	} while (0)
-#define DUK_ERROR_RAW_FMT2(thr,file,line,err,fmt,arg1,arg2) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
-	} while (0)
-
-#define DUK_ERROR_FMT3(thr,err,fmt,arg1,arg2,arg3) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \
-	} while (0)
-#define DUK_ERROR_RAW_FMT3(thr,file,line,err,fmt,arg1,arg2,arg3) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \
-	} while (0)
-
-#define DUK_ERROR_FMT4(thr,err,fmt,arg1,arg2,arg3,arg4) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3), (arg4)); \
-	} while (0)
-#define DUK_ERROR_RAW_FMT4(thr,file,line,err,fmt,arg1,arg2,arg3,arg4) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3), (arg4)); \
-	} while (0)
-
-#else  /* DUK_USE_VERBOSE_ERRORS */
-
-#define DUK_ERROR(thr,err,msg)                    duk_err_handle_error((thr), (err))
-#define DUK_ERROR_RAW(thr,file,line,err,msg)      duk_err_handle_error((thr), (err))
-
-#define DUK_ERROR_FMT1(thr,err,fmt,arg1) DUK_ERROR((thr),(err),(fmt))
-#define DUK_ERROR_RAW_FMT1(thr,file,line,err,fmt,arg1) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
-
-#define DUK_ERROR_FMT2(thr,err,fmt,arg1,arg2) DUK_ERROR((thr),(err),(fmt))
-#define DUK_ERROR_RAW_FMT2(thr,file,line,err,fmt,arg1,arg2) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
-
-#define DUK_ERROR_FMT3(thr,err,fmt,arg1,arg2,arg3) DUK_ERROR((thr),(err),(fmt))
-#define DUK_ERROR_RAW_FMT3(thr,file,line,err,fmt,arg1,arg2,arg3) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
-
-#define DUK_ERROR_FMT4(thr,err,fmt,arg1,arg2,arg3,arg4) DUK_ERROR((thr),(err),(fmt))
-#define DUK_ERROR_RAW_FMT4(thr,file,line,err,fmt,arg1,arg2,arg3,arg4) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
-
-#endif  /* DUK_USE_VERBOSE_ERRORS */
-
-/*
- *  Fatal error
- *
- *  There are no fatal error macros at the moment.  There are so few call
- *  sites that the fatal error handler is called directly.
- */
-
-/*
- *  Panic error
- *
- *  Panic errors are not relative to either a heap or a thread, and cause
- *  DUK_PANIC() macro to be invoked.  Unless a user provides DUK_USE_PANIC_HANDLER,
- *  DUK_PANIC() calls a helper which prints out the error and causes a process
- *  exit.
- *
- *  The user can override the macro to provide custom handling.  A macro is
- *  used to allow the user to have inline panic handling if desired (without
- *  causing a potentially risky function call).
- *
- *  Panics are only used in debug code such as assertions, and by the default
- *  fatal error handler.
- */
-
-#if defined(DUK_USE_PANIC_HANDLER)
-/* already defined, good */
-#define DUK_PANIC(code,msg)  DUK_USE_PANIC_HANDLER((code),(msg))
-#else
-#define DUK_PANIC(code,msg)  duk_default_panic_handler((code),(msg))
-#endif  /* DUK_USE_PANIC_HANDLER */
-
-/*
- *  Assert macro: failure causes panic.
- */
-
-#if defined(DUK_USE_ASSERTIONS)
-
-/* the message should be a compile time constant without formatting (less risk);
- * we don't care about assertion text size because they're not used in production
- * builds.
- */
-#define DUK_ASSERT(x)  do { \
-	if (!(x)) { \
-		DUK_PANIC(DUK_ERR_ASSERTION_ERROR, \
-			"assertion failed: " #x \
-			" (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"); \
-	} \
-	} while (0)
-
-/* Assertion compatible inside a comma expression, evaluates to void.
- * Currently not compatible with DUK_USE_PANIC_HANDLER() which may have
- * a statement block.
- */
-#if defined(DUK_USE_PANIC_HANDLER)
-/* XXX: resolve macro definition issue or call through a helper function? */
-#define DUK_ASSERT_EXPR(x)  ((void) 0)
-#else
-#define DUK_ASSERT_EXPR(x) \
-	((void) ((x) ? 0 : (DUK_PANIC(DUK_ERR_ASSERTION_ERROR, \
-				"assertion failed: " #x \
-				" (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"), 0)))
-#endif
-
-#else  /* DUK_USE_ASSERTIONS */
-
-#define DUK_ASSERT(x)  do { /* assertion omitted */ } while (0)
-
-#define DUK_ASSERT_EXPR(x)  ((void) 0)
-
-#endif  /* DUK_USE_ASSERTIONS */
-
-/* this variant is used when an assert would generate a compile warning by
- * being always true (e.g. >= 0 comparison for an unsigned value
- */
-#define DUK_ASSERT_DISABLE(x)  do { /* assertion disabled */ } while (0)
-
-/*
- *  Assertion helpers
- */
-
-#if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_REFERENCE_COUNTING)
-#define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h)  do { \
-		DUK_ASSERT((h) == NULL || DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) (h)) > 0); \
-	} while (0)
-#define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv)  do { \
-		if ((tv) != NULL && DUK_TVAL_IS_HEAP_ALLOCATED((tv))) { \
-			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(DUK_TVAL_GET_HEAPHDR((tv))) > 0); \
-		} \
-	} while (0)
-#else
-#define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h)  /* no refcount check */
-#define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv)    /* no refcount check */
-#endif
-
-#define DUK_ASSERT_TOP(ctx,n)  DUK_ASSERT((duk_idx_t) duk_get_top((ctx)) == (duk_idx_t) (n))
-
-#if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_PACKED_TVAL)
-#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval)  do { \
-		duk_double_union duk__assert_tmp_du; \
-		duk__assert_tmp_du.d = (dval); \
-		DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&duk__assert_tmp_du)); \
-	} while (0)
-#else
-#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval)  /* nop */
-#endif
-
-/*
- *  Helper for valstack space
- *
- *  Caller of DUK_ASSERT_VALSTACK_SPACE() estimates the number of free stack entries
- *  required for its own use, and any child calls which are not (a) Duktape API calls
- *  or (b) Duktape calls which involve extending the valstack (e.g. getter call).
- */
-
-#define DUK_VALSTACK_ASSERT_EXTRA  5  /* this is added to checks to allow for Duktape
-                                       * API calls in addition to function's own use
-                                       */
-#if defined(DUK_USE_ASSERTIONS)
-#define DUK_ASSERT_VALSTACK_SPACE(thr,n)   do { \
-		DUK_ASSERT((thr) != NULL); \
-		DUK_ASSERT((thr)->valstack_end - (thr)->valstack_top >= (n) + DUK_VALSTACK_ASSERT_EXTRA); \
-	} while (0)
-#else
-#define DUK_ASSERT_VALSTACK_SPACE(thr,n)   /* no valstack space check */
-#endif
-
-/*
- *  Error throwing helpers
- *
- *  The goal is to provide verbose and configurable error messages.  Call
- *  sites should be clean in source code and compile to a small footprint.
- *  Small footprint is also useful for performance because small cold paths
- *  reduce code cache pressure.  Adding macros here only makes sense if there
- *  are enough call sites to get concrete benefits.
- */
-
-#if defined(DUK_USE_VERBOSE_ERRORS)
-/* Verbose errors with key/value summaries (non-paranoid) or without key/value
- * summaries (paranoid, for some security sensitive environments), the paranoid
- * vs. non-paranoid distinction affects only a few specific errors.
- */
-#if defined(DUK_USE_PARANOID_ERRORS)
-#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,index,expectname,lowmemstr) do { \
-		duk_err_require_type_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (index), (expectname)); \
-	} while (0)
-#else  /* DUK_USE_PARANOID_ERRORS */
-#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,index,expectname,lowmemstr) do { \
-		duk_err_require_type_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (index), (expectname)); \
-	} while (0)
-#endif  /* DUK_USE_PARANOID_ERRORS */
-
-#define DUK_ERROR_UNIMPLEMENTED(thr,msg) do { \
-		DUK_ERROR((thr), DUK_ERR_UNIMPLEMENTED_ERROR, (msg)); \
-	} while (0)
-#define DUK_ERROR_UNIMPLEMENTED_DEFMSG(thr) do { \
-		duk_err_unimplemented_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
-	} while (0)
-#define DUK_ERROR_UNSUPPORTED(thr,msg) do { \
-		DUK_ERROR((thr), DUK_ERR_UNSUPPORTED_ERROR, (msg)); \
-	} while (0)
-#if !defined(DUK_USE_BYTECODE_DUMP_SUPPORT)
-#define DUK_ERROR_UNSUPPORTED_DEFMSG(thr) do { \
-		duk_err_unsupported_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
-	} while (0)
-#endif
-#define DUK_ERROR_INTERNAL(thr,msg) do { \
-		duk_err_internal((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
-	} while (0)
-#define DUK_ERROR_INTERNAL_DEFMSG(thr) do { \
-		duk_err_internal_defmsg((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
-	} while (0)
-#define DUK_ERROR_ALLOC(thr,msg) do { \
-		duk_err_alloc((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
-	} while (0)
-#define DUK_ERROR_ALLOC_DEFMSG(thr) do { \
-		DUK_ERROR_ALLOC((thr), DUK_STR_ALLOC_FAILED); \
-	} while (0)
-/* DUK_ERR_ASSERTION_ERROR: no macros needed */
-#define DUK_ERROR_API_INDEX(thr,index) do { \
-		duk_err_api_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (index)); \
-	} while (0)
-#define DUK_ERROR_API(thr,msg) do { \
-		duk_err_api((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
-	} while (0)
-/* DUK_ERR_UNCAUGHT_ERROR: no macros needed */
-/* DUK_ERR_ERROR: no macros needed */
-/* DUK_ERR_EVAL: no macros needed */
-#define DUK_ERROR_RANGE(thr,msg) do { \
-		duk_err_range((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
-	} while (0)
-/* DUK_ERR_REFERENCE_ERROR: no macros needed */
-#define DUK_ERROR_SYNTAX(thr,msg) do { \
-		DUK_ERROR((thr), DUK_ERR_SYNTAX_ERROR, (msg)); \
-	} while (0)
-#define DUK_ERROR_TYPE(thr,msg) do { \
-		DUK_ERROR((thr), DUK_ERR_TYPE_ERROR, (msg)); \
-	} while (0)
-/* DUK_ERR_URI_ERROR: no macros needed */
-#else  /* DUK_USE_VERBOSE_ERRORS */
-/* Non-verbose errors for low memory targets: no file, line, or message. */
-
-#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,index,expectname,lowmemstr) do { \
-		duk_err_type((thr)); \
-	} while (0)
-
-#define DUK_ERROR_UNIMPLEMENTED(thr,msg) do { \
-		duk_err_unimplemented((thr)); \
-	} while (0)
-#define DUK_ERROR_UNIMPLEMENTED_DEFMSG(thr) do { \
-		duk_err_unimplemented((thr)); \
-	} while (0)
-#define DUK_ERROR_UNSUPPORTED(thr,msg) do { \
-		duk_err_unsupported((thr)); \
-	} while (0)
-#define DUK_ERROR_UNSUPPORTED_DEFMSG(thr) do { \
-		duk_err_unsupported((thr)); \
-	} while (0)
-#define DUK_ERROR_INTERNAL(thr,msg) do { \
-		duk_err_internal((thr)); \
-	} while (0)
-#define DUK_ERROR_INTERNAL_DEFMSG(thr) do { \
-		duk_err_internal((thr)); \
-	} while (0)
-#define DUK_ERROR_ALLOC(thr,msg) do { \
-		duk_err_alloc((thr)); \
-	} while (0)
-#define DUK_ERROR_ALLOC_DEFMSG(thr) do { \
-		duk_err_alloc((thr)); \
-	} while (0)
-#define DUK_ERROR_API_INDEX(thr,index) do { \
-		duk_err_api((thr)); \
-	} while (0)
-#define DUK_ERROR_API(thr,msg) do { \
-		duk_err_api((thr)); \
-	} while (0)
-#define DUK_ERROR_RANGE(thr,msg) do { \
-		duk_err_range((thr)); \
-	} while (0)
-#define DUK_ERROR_SYNTAX(thr,msg) do { \
-		duk_err_syntax((thr)); \
-	} while (0)
-#define DUK_ERROR_TYPE(thr,msg) do { \
-		duk_err_type((thr)); \
-	} while (0)
-#endif  /* DUK_USE_VERBOSE_ERRORS */
-
-/*
- *  Prototypes
- */
-
-#if defined(DUK_USE_VERBOSE_ERRORS)
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *msg));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_fmt(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *fmt, ...));
-#else  /* DUK_USE_VERBOSE_ERRORS */
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code));
-#endif  /* DUK_USE_VERBOSE_ERRORS */
-
-#if defined(DUK_USE_VERBOSE_ERRORS)
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code, const char *msg, const char *filename, duk_int_t line));
-#else
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code));
-#endif
-
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc));
-
-#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
-DUK_INTERNAL_DECL void duk_err_augment_error_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *filename, duk_int_t line, duk_bool_t noblame_fileline);
-#endif
-#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-DUK_INTERNAL_DECL void duk_err_augment_error_throw(duk_hthread *thr);
-#endif
-
-#if defined(DUK_USE_VERBOSE_ERRORS)
-#if defined(DUK_USE_PARANOID_ERRORS)
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index, const char *expect_name));
-#else
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index, const char *expect_name));
-#endif
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_api_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_api(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_unimplemented_defmsg(duk_hthread *thr, const char *filename, duk_int_t linenumber));
-#if !defined(DUK_USE_BYTECODE_DUMP_SUPPORT)
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_unsupported_defmsg(duk_hthread *thr, const char *filename, duk_int_t linenumber));
-#endif
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_internal_defmsg(duk_hthread *thr, const char *filename, duk_int_t linenumber));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_internal(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_alloc(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message));
-#else  /* DUK_VERBOSE_ERRORS */
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range(duk_hthread *thr));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_syntax(duk_hthread *thr));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_type(duk_hthread *thr));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_api(duk_hthread *thr));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_unimplemented(duk_hthread *thr));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_unsupported(duk_hthread *thr));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_internal(duk_hthread *thr));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_alloc(duk_hthread *thr));
-#endif /* DUK_VERBOSE_ERRORS */
-
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_longjmp(duk_hthread *thr));
-
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_default_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg));
-
-#if !defined(DUK_USE_PANIC_HANDLER)
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_default_panic_handler(duk_errcode_t code, const char *msg));
-#endif
-
-DUK_INTERNAL_DECL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type);
-
-DUK_INTERNAL_DECL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t err_code);
-
-#endif  /* DUK_ERROR_H_INCLUDED */

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_error_augment.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_augment.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_augment.c
deleted file mode 100644
index ea15690..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_augment.c
+++ /dev/null
@@ -1,567 +0,0 @@
-/*
- *  Augmenting errors at their creation site and their throw site.
- *
- *  When errors are created, traceback data is added by built-in code
- *  and a user error handler (if defined) can process or replace the
- *  error.  Similarly, when errors are thrown, a user error handler
- *  (if defined) can process or replace the error.
- *
- *  Augmentation and other processing at error creation time is nice
- *  because an error is only created once, but it may be thrown and
- *  rethrown multiple times.  User error handler registered for processing
- *  an error at its throw site must be careful to handle rethrowing in
- *  a useful manner.
- *
- *  Error augmentation may throw an internal error (e.g. alloc error).
- *
- *  Ecmascript allows throwing any values, so all values cannot be
- *  augmented.  Currently, the built-in augmentation at error creation
- *  only augments error values which are Error instances (= have the
- *  built-in Error.prototype in their prototype chain) and are also
- *  extensible.  User error handlers have no limitations in this respect.
- */
-
-#include "duk_internal.h"
-
-/*
- *  Helper for calling a user error handler.
- *
- *  'thr' must be the currently active thread; the error handler is called
- *  in its context.  The valstack of 'thr' must have the error value on
- *  top, and will be replaced by another error value based on the return
- *  value of the error handler.
- *
- *  The helper calls duk_handle_call() recursively in protected mode.
- *  Before that call happens, no longjmps should happen; as a consequence,
- *  we must assume that the valstack contains enough temporary space for
- *  arguments and such.
- *
- *  While the error handler runs, any errors thrown will not trigger a
- *  recursive error handler call (this is implemented using a heap level
- *  flag which will "follow" through any coroutines resumed inside the
- *  error handler).  If the error handler is not callable or throws an
- *  error, the resulting error replaces the original error (for Duktape
- *  internal errors, duk_error_throw.c further substitutes this error with
- *  a DoubleError which is not ideal).  This would be easy to change and
- *  even signal to the caller.
- *
- *  The user error handler is stored in 'Duktape.errCreate' or
- *  'Duktape.errThrow' depending on whether we're augmenting the error at
- *  creation or throw time.  There are several alternatives to this approach,
- *  see doc/error-objects.rst for discussion.
- *
- *  Note: since further longjmp()s may occur while calling the error handler
- *  (for many reasons, e.g. a labeled 'break' inside the handler), the
- *  caller can make no assumptions on the thr->heap->lj state after the
- *  call (this affects especially duk_error_throw.c).  This is not an issue
- *  as long as the caller writes to the lj state only after the error handler
- *  finishes.
- */
-
-#if defined(DUK_USE_ERRTHROW) || defined(DUK_USE_ERRCREATE)
-DUK_LOCAL void duk__err_augment_user(duk_hthread *thr, duk_small_uint_t stridx_cb) {
-	duk_context *ctx = (duk_context *) thr;
-	duk_tval *tv_hnd;
-	duk_small_uint_t call_flags;
-	duk_int_t rc;
-
-	DUK_ASSERT(thr != NULL);
-	DUK_ASSERT(thr->heap != NULL);
-	DUK_ASSERT_DISABLE(stridx_cb >= 0);  /* unsigned */
-	DUK_ASSERT(stridx_cb < DUK_HEAP_NUM_STRINGS);
-
-	if (DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)) {
-		DUK_DD(DUK_DDPRINT("recursive call to error handler, ignore"));
-		return;
-	}
-
-	/*
-	 *  Check whether or not we have an error handler.
-	 *
-	 *  We must be careful of not triggering an error when looking up the
-	 *  property.  For instance, if the property is a getter, we don't want
-	 *  to call it, only plain values are allowed.  The value, if it exists,
-	 *  is not checked.  If the value is not a function, a TypeError happens
-	 *  when it is called and that error replaces the original one.
-	 */
-
-	DUK_ASSERT_VALSTACK_SPACE(thr, 4);  /* 3 entries actually needed below */
-
-	/* [ ... errval ] */
-
-	if (thr->builtins[DUK_BIDX_DUKTAPE] == NULL) {
-		/* When creating built-ins, some of the built-ins may not be set
-		 * and we want to tolerate that when throwing errors.
-		 */
-		DUK_DD(DUK_DDPRINT("error occurred when DUK_BIDX_DUKTAPE is NULL, ignoring"));
-		return;
-	}
-	tv_hnd = duk_hobject_find_existing_entry_tval_ptr(thr->heap,
-	                                                  thr->builtins[DUK_BIDX_DUKTAPE],
-	                                                  DUK_HTHREAD_GET_STRING(thr, stridx_cb));
-	if (tv_hnd == NULL) {
-		DUK_DD(DUK_DDPRINT("error handler does not exist or is not a plain value: %!T",
-		                   (duk_tval *) tv_hnd));
-		return;
-	}
-	DUK_DDD(DUK_DDDPRINT("error handler dump (callability not checked): %!T",
-	                     (duk_tval *) tv_hnd));
-	duk_push_tval(ctx, tv_hnd);
-
-	/* [ ... errval errhandler ] */
-
-	duk_insert(ctx, -2);  /* -> [ ... errhandler errval ] */
-	duk_push_undefined(ctx);
-	duk_insert(ctx, -2);  /* -> [ ... errhandler undefined(= this) errval ] */
-
-	/* [ ... errhandler undefined errval ] */
-
-	/*
-	 *  DUK_CALL_FLAG_IGNORE_RECLIMIT causes duk_handle_call() to ignore C
-	 *  recursion depth limit (and won't increase it either).  This is
-	 *  dangerous, but useful because it allows the error handler to run
-	 *  even if the original error is caused by C recursion depth limit.
-	 *
-	 *  The heap level DUK_HEAP_FLAG_ERRHANDLER_RUNNING is set for the
-	 *  duration of the error handler and cleared afterwards.  This flag
-	 *  prevents the error handler from running recursively.  The flag is
-	 *  heap level so that the flag properly controls even coroutines
-	 *  launched by an error handler.  Since the flag is heap level, it is
-	 *  critical to restore it correctly.
-	 *
-	 *  We ignore errors now: a success return and an error value both
-	 *  replace the original error value.  (This would be easy to change.)
-	 */
-
-	DUK_ASSERT(!DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap));  /* since no recursive error handler calls */
-	DUK_HEAP_SET_ERRHANDLER_RUNNING(thr->heap);
-
-	call_flags = DUK_CALL_FLAG_IGNORE_RECLIMIT;  /* ignore reclimit, not constructor */
-
-	rc = duk_handle_call_protected(thr,
-	                               1,            /* num args */
-	                               call_flags);  /* call_flags */
-	DUK_UNREF(rc);  /* no need to check now: both success and error are OK */
-
-	DUK_ASSERT(DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap));
-	DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(thr->heap);
-
-	/* [ ... errval ] */
-}
-#endif  /* DUK_USE_ERRTHROW || DUK_USE_ERRCREATE */
-
-/*
- *  Add ._Tracedata to an error on the stack top.
- */
-
-#if defined(DUK_USE_TRACEBACKS)
-DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) {
-	duk_context *ctx = (duk_context *) thr;
-	duk_small_uint_t depth;
-	duk_int_t i, i_min;
-	duk_uarridx_t arr_idx;
-	duk_double_t d;
-
-	DUK_ASSERT(thr != NULL);
-	DUK_ASSERT(thr_callstack != NULL);
-	DUK_ASSERT(ctx != NULL);
-
-	/* [ ... error ] */
-
-	/*
-	 *  The traceback format is pretty arcane in an attempt to keep it compact
-	 *  and cheap to create.  It may change arbitrarily from version to version.
-	 *  It should be decoded/accessed through version specific accessors only.
-	 *
-	 *  See doc/error-objects.rst.
-	 */
-
-	DUK_DDD(DUK_DDDPRINT("adding traceback to object: %!T",
-	                     (duk_tval *) duk_get_tval(ctx, -1)));
-
-	duk_push_array(ctx);  /* XXX: specify array size, as we know it */
-	arr_idx = 0;
-
-	/* Compiler SyntaxErrors (and other errors) come first, and are
-	 * blamed by default (not flagged "noblame").
-	 */
-	if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
-		duk_push_hstring(ctx, thr->compile_ctx->h_filename);
-		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-		arr_idx++;
-
-		duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line);  /* (flags<<32) + (line), flags = 0 */
-		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-		arr_idx++;
-	}
-
-	/* Filename/line from C macros (__FILE__, __LINE__) are added as an
-	 * entry with a special format: (string, number).  The number contains
-	 * the line and flags.
-	 */
-
-	/* XXX: optimize: allocate an array part to the necessary size (upwards
-	 * estimate) and fill in the values directly into the array part; finally
-	 * update 'length'.
-	 */
-
-	/* XXX: using duk_put_prop_index() would cause obscure error cases when Array.prototype
-	 * has write-protected array index named properties.  This was seen as DoubleErrors
-	 * in e.g. some test262 test cases.  Using duk_xdef_prop_index() is better but heavier.
-	 * The best fix is to fill in the tracedata directly into the array part.  There are
-	 * no side effect concerns if the array part is allocated directly and only INCREFs
-	 * happen after that.
-	 */
-
-	/* [ ... error arr ] */
-
-	if (c_filename) {
-		duk_push_string(ctx, c_filename);
-		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-		arr_idx++;
-
-		d = (noblame_fileline ? ((duk_double_t) DUK_TB_FLAG_NOBLAME_FILELINE) * DUK_DOUBLE_2TO32 : 0.0) +
-		    (duk_double_t) c_line;
-		duk_push_number(ctx, d);
-		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-		arr_idx++;
-	}
-
-	/* traceback depth doesn't take into account the filename/line
-	 * special handling above (intentional)
-	 */
-	depth = DUK_USE_TRACEBACK_DEPTH;
-	i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0);
-	DUK_ASSERT(i_min >= 0);
-
-	/* [ ... error arr ] */
-
-	DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX);  /* callstack limits */
-	for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) {
-		duk_uint32_t pc;
-
-		/*
-		 *  Note: each API operation potentially resizes the callstack,
-		 *  so be careful to re-lookup after every operation.  Currently
-		 *  these is no issue because we don't store a temporary 'act'
-		 *  pointer at all.  (This would be a non-issue if we operated
-		 *  directly on the array part.)
-		 */
-
-		/* [... arr] */
-
-		DUK_ASSERT_DISABLE(thr_callstack->callstack[i].pc >= 0);  /* unsigned */
-
-		/* Add function object. */
-		duk_push_tval(ctx, &(thr_callstack->callstack + i)->tv_func);
-		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-		arr_idx++;
-
-		/* Add a number containing: pc, activation flags.
-		 *
-		 * PC points to next instruction, find offending PC.  Note that
-		 * PC == 0 for native code.
-		 */
-		pc = duk_hthread_get_act_prev_pc(thr_callstack, thr_callstack->callstack + i);
-		DUK_ASSERT_DISABLE(pc >= 0);  /* unsigned */
-		DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32);  /* assume PC is at most 32 bits and non-negative */
-		d = ((duk_double_t) thr_callstack->callstack[i].flags) * DUK_DOUBLE_2TO32 + (duk_double_t) pc;
-		duk_push_number(ctx, d);  /* -> [... arr num] */
-		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-		arr_idx++;
-	}
-
-	/* XXX: set with duk_hobject_set_length() when tracedata is filled directly */
-	duk_push_uint(ctx, (duk_uint_t) arr_idx);
-	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_WC);
-
-	/* [ ... error arr ] */
-
-	duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_TRACEDATA);  /* -> [ ... error ] */
-}
-#endif  /* DUK_USE_TRACEBACKS */
-
-/*
- *  Add .fileName and .lineNumber to an error on the stack top.
- */
-
-#if !defined(DUK_USE_TRACEBACKS)
-DUK_LOCAL void duk__add_fileline(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) {
-	duk_context *ctx;
-#if defined(DUK_USE_ASSERTIONS)
-	duk_int_t entry_top;
-#endif
-
-	ctx = (duk_context *) thr;
-#if defined(DUK_USE_ASSERTIONS)
-	entry_top = duk_get_top(ctx);
-#endif
-
-	/*
-	 *  If tracebacks are disabled, 'fileName' and 'lineNumber' are added
-	 *  as plain own properties.  Since Error.prototype has accessors of
-	 *  the same name, we need to define own properties directly (cannot
-	 *  just use e.g. duk_put_prop_stridx).  Existing properties are not
-	 *  overwritten in case they already exist.
-	 */
-
-	if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
-		/* Compiler SyntaxError (or other error) gets the primary blame.
-		 * Currently no flag to prevent blaming.
-		 */
-		duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line);
-		duk_push_hstring(ctx, thr->compile_ctx->h_filename);
-	} else if (c_filename && !noblame_fileline) {
-		/* C call site gets blamed next, unless flagged not to do so.
-		 * XXX: file/line is disabled in minimal builds, so disable this
-		 * too when appropriate.
-		 */
-		duk_push_int(ctx, c_line);
-		duk_push_string(ctx, c_filename);
-	} else {
-		/* Finally, blame the innermost callstack entry which has a
-		 * .fileName property.
-		 */
-		duk_small_uint_t depth;
-		duk_int_t i, i_min;
-		duk_uint32_t ecma_line;
-
-		depth = DUK_USE_TRACEBACK_DEPTH;
-		i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0);
-		DUK_ASSERT(i_min >= 0);
-
-		DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX);  /* callstack limits */
-		for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) {
-			duk_activation *act;
-			duk_hobject *func;
-			duk_uint32_t pc;
-
-			DUK_UNREF(pc);
-			act = thr_callstack->callstack + i;
-			DUK_ASSERT(act >= thr_callstack->callstack && act < thr_callstack->callstack + thr_callstack->callstack_size);
-
-			func = DUK_ACT_GET_FUNC(act);
-			if (func == NULL) {
-				/* Lightfunc, not blamed now. */
-				continue;
-			}
-
-			/* PC points to next instruction, find offending PC,
-			 * PC == 0 for native code.
-			 */
-			pc = duk_hthread_get_act_prev_pc(thr, act);  /* thr argument only used for thr->heap, so specific thread doesn't matter */
-			DUK_ASSERT_DISABLE(pc >= 0);  /* unsigned */
-			DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32);  /* assume PC is at most 32 bits and non-negative */
-			act = NULL;  /* invalidated by pushes, so get out of the way */
-
-			duk_push_hobject(ctx, func);
-
-			/* [ ... error func ] */
-
-			duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME);
-			if (!duk_is_string(ctx, -1)) {
-				duk_pop_2(ctx);
-				continue;
-			}
-
-			/* [ ... error func fileName ] */
-
-			ecma_line = 0;
-#if defined(DUK_USE_PC2LINE)
-			if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
-				ecma_line = duk_hobject_pc2line_query(ctx, -2, (duk_uint_fast32_t) pc);
-			} else {
-				/* Native function, no relevant lineNumber. */
-			}
-#endif  /* DUK_USE_PC2LINE */
-			duk_push_u32(ctx, ecma_line);
-
-			/* [ ... error func fileName lineNumber ] */
-
-			duk_replace(ctx, -3);
-
-			/* [ ... error lineNumber fileName ] */
-			goto define_props;
-		}
-
-		/* No activation matches, use undefined for both .fileName and
-		 * .lineNumber (matches what we do with a _Tracedata based
-		 * no-match lookup.
-		 */
-		duk_push_undefined(ctx);
-		duk_push_undefined(ctx);
-	}
-
- define_props:
-	/* [ ... error lineNumber fileName ] */
-#if defined(DUK_USE_ASSERTIONS)
-	DUK_ASSERT(duk_get_top(ctx) == entry_top + 2);
-#endif
-	duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
-	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
-}
-#endif  /* !DUK_USE_TRACEBACKS */
-
-/*
- *  Add line number to a compiler error.
- */
-
-DUK_LOCAL void duk__add_compiler_error_line(duk_hthread *thr) {
-	duk_context *ctx;
-
-	/* Append a "(line NNN)" to the "message" property of any error
-	 * thrown during compilation.  Usually compilation errors are
-	 * SyntaxErrors but they can also be out-of-memory errors and
-	 * the like.
-	 */
-
-	/* [ ... error ] */
-
-	ctx = (duk_context *) thr;
-	DUK_ASSERT(duk_is_object(ctx, -1));
-
-	if (!(thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL)) {
-		return;
-	}
-
-	DUK_DDD(DUK_DDDPRINT("compile error, before adding line info: %!T",
-	                     (duk_tval *) duk_get_tval(ctx, -1)));
-
-	if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_MESSAGE)) {
-		duk_push_sprintf(ctx, " (line %ld)", (long) thr->compile_ctx->curr_token.start_line);
-		duk_concat(ctx, 2);
-		duk_put_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE);
-	} else {
-		duk_pop(ctx);
-	}
-
-	DUK_DDD(DUK_DDDPRINT("compile error, after adding line info: %!T",
-	                     (duk_tval *) duk_get_tval(ctx, -1)));
-}
-
-/*
- *  Augment an error being created using Duktape specific properties
- *  like _Tracedata or .fileName/.lineNumber.
- */
-
-#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
-DUK_LOCAL void duk__err_augment_builtin_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_small_int_t noblame_fileline, duk_hobject *obj) {
-	duk_context *ctx = (duk_context *) thr;
-#if defined(DUK_USE_ASSERTIONS)
-	duk_int_t entry_top;
-#endif
-
-#if defined(DUK_USE_ASSERTIONS)
-	entry_top = duk_get_top(ctx);
-#endif
-	DUK_ASSERT(obj != NULL);
-
-	DUK_UNREF(obj);  /* unreferenced w/o tracebacks */
-	DUK_UNREF(ctx);  /* unreferenced w/o asserts */
-
-	duk__add_compiler_error_line(thr);
-
-#if defined(DUK_USE_TRACEBACKS)
-	/* If tracebacks are enabled, the '_Tracedata' property is the only
-	 * thing we need: 'fileName' and 'lineNumber' are virtual properties
-	 * which use '_Tracedata'.
-	 */
-	if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_INT_TRACEDATA(thr))) {
-		DUK_DDD(DUK_DDDPRINT("error value already has a '_Tracedata' property, not modifying it"));
-	} else {
-		duk__add_traceback(thr, thr_callstack, c_filename, c_line, noblame_fileline);
-	}
-#else
-	/* Without tracebacks the concrete .fileName and .lineNumber need
-	 * to be added directly.
-	 */
-	duk__add_fileline(thr, thr_callstack, c_filename, c_line, noblame_fileline);
-#endif
-
-#if defined(DUK_USE_ASSERTIONS)
-	DUK_ASSERT(duk_get_top(ctx) == entry_top);
-#endif
-}
-#endif  /* DUK_USE_AUGMENT_ERROR_CREATE */
-
-/*
- *  Augment an error at creation time with _Tracedata/fileName/lineNumber
- *  and allow a user error handler (if defined) to process/replace the error.
- *  The error to be augmented is at the stack top.
- *
- *  thr: thread containing the error value
- *  thr_callstack: thread which should be used for generating callstack etc.
- *  c_filename: C __FILE__ related to the error
- *  c_line: C __LINE__ related to the error
- *  noblame_fileline: if true, don't fileName/line as error source, otherwise use traceback
- *                    (needed because user code filename/line are reported but internal ones
- *                    are not)
- *
- *  XXX: rename noblame_fileline to flags field; combine it to some existing
- *  field (there are only a few call sites so this may not be worth it).
- */
-
-#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
-DUK_INTERNAL void duk_err_augment_error_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) {
-	duk_context *ctx = (duk_context *) thr;
-	duk_hobject *obj;
-
-	DUK_ASSERT(thr != NULL);
-	DUK_ASSERT(thr_callstack != NULL);
-	DUK_ASSERT(ctx != NULL);
-
-	/* [ ... error ] */
-
-	/*
-	 *  Criteria for augmenting:
-	 *
-	 *   - augmentation enabled in build (naturally)
-	 *   - error value internal prototype chain contains the built-in
-	 *     Error prototype object (i.e. 'val instanceof Error')
-	 *
-	 *  Additional criteria for built-in augmenting:
-	 *
-	 *   - error value is an extensible object
-	 */
-
-	obj = duk_get_hobject(ctx, -1);
-	if (!obj) {
-		DUK_DDD(DUK_DDDPRINT("value is not an object, skip both built-in and user augment"));
-		return;
-	}
-	if (!duk_hobject_prototype_chain_contains(thr, obj, thr->builtins[DUK_BIDX_ERROR_PROTOTYPE], 1 /*ignore_loop*/)) {
-		/* If the value has a prototype loop, it's critical not to
-		 * throw here.  Instead, assume the value is not to be
-		 * augmented.
-		 */
-		DUK_DDD(DUK_DDDPRINT("value is not an error instance, skip both built-in and user augment"));
-		return;
-	}
-	if (DUK_HOBJECT_HAS_EXTENSIBLE(obj)) {
-		DUK_DDD(DUK_DDDPRINT("error meets criteria, built-in augment"));
-		duk__err_augment_builtin_create(thr, thr_callstack, c_filename, c_line, noblame_fileline, obj);
-	} else {
-		DUK_DDD(DUK_DDDPRINT("error does not meet criteria, no built-in augment"));
-	}
-
-	/* [ ... error ] */
-
-#if defined(DUK_USE_ERRCREATE)
-	duk__err_augment_user(thr, DUK_STRIDX_ERR_CREATE);
-#endif
-}
-#endif  /* DUK_USE_AUGMENT_ERROR_CREATE */
-
-/*
- *  Augment an error at throw time; allow a user error handler (if defined)
- *  to process/replace the error.  The error to be augmented is at the
- *  stack top.
- */
-
-#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-DUK_INTERNAL void duk_err_augment_error_throw(duk_hthread *thr) {
-#if defined(DUK_USE_ERRTHROW)
-	duk__err_augment_user(thr, DUK_STRIDX_ERR_THROW);
-#endif  /* DUK_USE_ERRTHROW */
-}
-#endif  /* DUK_USE_AUGMENT_ERROR_THROW */

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_error_longjmp.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_longjmp.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_longjmp.c
deleted file mode 100644
index bfb1b46..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_longjmp.c
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- *  Do a longjmp call, calling the fatal error handler if no
- *  catchpoint exists.
- */
-
-#include "duk_internal.h"
-
-DUK_INTERNAL void duk_err_longjmp(duk_hthread *thr) {
-	DUK_ASSERT(thr != NULL);
-
-	DUK_DD(DUK_DDPRINT("longjmp error: type=%d iserror=%d value1=%!T value2=%!T",
-	                   (int) thr->heap->lj.type, (int) thr->heap->lj.iserror,
-	                   &thr->heap->lj.value1, &thr->heap->lj.value2));
-
-#if !defined(DUK_USE_CPP_EXCEPTIONS)
-	/* If we don't have a jmpbuf_ptr, there is little we can do
-	 * except panic.  The caller's expectation is that we never
-	 * return.
-	 *
-	 * With C++ exceptions we now just propagate an uncaught error
-	 * instead of invoking the fatal error handler.  Because there's
-	 * a dummy jmpbuf for C++ exceptions now, this could be changed.
-	 */
-	if (!thr->heap->lj.jmpbuf_ptr) {
-
-		DUK_D(DUK_DPRINT("uncaught error: type=%d iserror=%d value1=%!T value2=%!T",
-		                 (int) thr->heap->lj.type, (int) thr->heap->lj.iserror,
-		                 &thr->heap->lj.value1, &thr->heap->lj.value2));
-
-		duk_fatal((duk_context *) thr, DUK_ERR_UNCAUGHT_ERROR, "uncaught error");
-		DUK_UNREACHABLE();
-	}
-#endif  /* DUK_USE_CPP_EXCEPTIONS */
-
-#if defined(DUK_USE_CPP_EXCEPTIONS)
-	{
-		duk_internal_exception exc;  /* dummy */
-		throw exc;
-	}
-#else  /* DUK_USE_CPP_EXCEPTIONS */
-	DUK_LONGJMP(thr->heap->lj.jmpbuf_ptr->jb);
-#endif  /* DUK_USE_CPP_EXCEPTIONS */
-
-	DUK_UNREACHABLE();
-}

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_error_macros.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_macros.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_macros.c
deleted file mode 100644
index 9334d1f..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_macros.c
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- *  Error, fatal, and panic handling.
- */
-
-#include "duk_internal.h"
-
-#define DUK__ERRFMT_BUFSIZE  256  /* size for formatting buffers */
-
-#if defined(DUK_USE_VERBOSE_ERRORS)
-
-DUK_INTERNAL void duk_err_handle_error_fmt(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *fmt, ...) {
-	va_list ap;
-	char msg[DUK__ERRFMT_BUFSIZE];
-	va_start(ap, fmt);
-	(void) DUK_VSNPRINTF(msg, sizeof(msg), fmt, ap);
-	msg[sizeof(msg) - 1] = (char) 0;
-	duk_err_create_and_throw(thr, (duk_errcode_t) (line_and_code >> 24), msg, filename, (duk_int_t) (line_and_code & 0x00ffffffL));
-	va_end(ap);  /* dead code, but ensures portability (see Linux man page notes) */
-}
-
-DUK_INTERNAL void duk_err_handle_error(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *msg) {
-	duk_err_create_and_throw(thr, (duk_errcode_t) (line_and_code >> 24), msg, filename, (duk_int_t) (line_and_code & 0x00ffffffL));
-}
-
-#else  /* DUK_USE_VERBOSE_ERRORS */
-
-DUK_INTERNAL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code) {
-	duk_err_create_and_throw(thr, code);
-}
-
-#endif  /* DUK_USE_VERBOSE_ERRORS */
-
-/*
- *  Error throwing helpers
- */
-
-#if defined(DUK_USE_VERBOSE_ERRORS)
-#if defined(DUK_USE_PARANOID_ERRORS)
-DUK_INTERNAL void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index, const char *expect_name) {
-	DUK_ERROR_RAW_FMT3(thr, filename, linenumber, DUK_ERR_TYPE_ERROR, "%s required, found %s (stack index %ld)",
-	                   expect_name, duk_get_type_name((duk_context *) thr, index), (long) index);
-}
-#else
-DUK_INTERNAL void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index, const char *expect_name) {
-	DUK_ERROR_RAW_FMT3(thr, filename, linenumber, DUK_ERR_TYPE_ERROR, "%s required, found %s (stack index %ld)",
-	                   expect_name, duk_push_string_readable((duk_context *) thr, index), (long) index);
-}
-#endif
-DUK_INTERNAL void duk_err_range(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message) {
-	DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_RANGE_ERROR, message);
-}
-DUK_INTERNAL void duk_err_api_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t index) {
-	DUK_ERROR_RAW_FMT1(thr, filename, linenumber, DUK_ERR_API_ERROR, "invalid stack index %ld", (long) (index));
-}
-DUK_INTERNAL void duk_err_api(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message) {
-	DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_API_ERROR, message);
-}
-DUK_INTERNAL void duk_err_unimplemented_defmsg(duk_hthread *thr, const char *filename, duk_int_t linenumber) {
-	DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_UNIMPLEMENTED_ERROR, DUK_STR_UNIMPLEMENTED);
-}
-#if !defined(DUK_USE_BYTECODE_DUMP_SUPPORT)
-DUK_INTERNAL void duk_err_unsupported_defmsg(duk_hthread *thr, const char *filename, duk_int_t linenumber) {
-	DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_UNSUPPORTED_ERROR, DUK_STR_UNSUPPORTED);
-}
-#endif
-DUK_INTERNAL void duk_err_internal_defmsg(duk_hthread *thr, const char *filename, duk_int_t linenumber) {
-	DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR);
-}
-DUK_INTERNAL void duk_err_internal(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message) {
-	DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_INTERNAL_ERROR, message);
-}
-DUK_INTERNAL void duk_err_alloc(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message) {
-	DUK_ERROR_RAW(thr, filename, linenumber, DUK_ERR_ALLOC_ERROR, message);
-}
-#else
-/* The file/line arguments are NULL and 0, they're ignored by DUK_ERROR_RAW()
- * when non-verbose errors are used.
- */
-DUK_INTERNAL void duk_err_type(duk_hthread *thr) {
-	DUK_ERROR_RAW(thr, NULL, 0, DUK_ERR_TYPE_ERROR, NULL);
-}
-DUK_INTERNAL void duk_err_api(duk_hthread *thr) {
-	DUK_ERROR_RAW(thr, NULL, 0, DUK_ERR_API_ERROR, NULL);
-}
-DUK_INTERNAL void duk_err_range(duk_hthread *thr) {
-	DUK_ERROR_RAW(thr, NULL, 0, DUK_ERR_RANGE_ERROR, NULL);
-}
-DUK_INTERNAL void duk_err_syntax(duk_hthread *thr) {
-	DUK_ERROR_RAW(thr, NULL, 0, DUK_ERR_SYNTAX_ERROR, NULL);
-}
-DUK_INTERNAL void duk_err_unimplemented(duk_hthread *thr) {
-	DUK_ERROR_RAW(thr, NULL, 0, DUK_ERR_UNIMPLEMENTED_ERROR, NULL);
-}
-DUK_INTERNAL void duk_err_unsupported(duk_hthread *thr) {
-	DUK_ERROR_RAW(thr, NULL, 0, DUK_ERR_UNSUPPORTED_ERROR, NULL);
-}
-DUK_INTERNAL void duk_err_internal(duk_hthread *thr) {
-	DUK_ERROR_RAW(thr, NULL, 0, DUK_ERR_INTERNAL_ERROR, NULL);
-}
-DUK_INTERNAL void duk_err_alloc(duk_hthread *thr) {
-	DUK_ERROR_RAW(thr, NULL, thr, DUK_ERR_ALLOC_ERROR, NULL);
-}
-#endif
-
-/*
- *  Default fatal error handler
- */
-
-DUK_INTERNAL void duk_default_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg) {
-	DUK_UNREF(ctx);
-#if defined(DUK_USE_FILE_IO)
-	DUK_FPRINTF(DUK_STDERR, "FATAL %ld: %s\n", (long) code, (const char *) (msg ? msg : "null"));
-	DUK_FFLUSH(DUK_STDERR);
-#else
-	/* omit print */
-#endif
-	DUK_D(DUK_DPRINT("default fatal handler called, code %ld -> calling DUK_PANIC()", (long) code));
-	DUK_PANIC(code, msg);
-	DUK_UNREACHABLE();
-}
-
-/*
- *  Default panic handler
- */
-
-#if !defined(DUK_USE_PANIC_HANDLER)
-DUK_INTERNAL void duk_default_panic_handler(duk_errcode_t code, const char *msg) {
-#if defined(DUK_USE_FILE_IO)
-	DUK_FPRINTF(DUK_STDERR, "PANIC %ld: %s ("
-#if defined(DUK_USE_PANIC_ABORT)
-	            "calling abort"
-#elif defined(DUK_USE_PANIC_EXIT)
-	            "calling exit"
-#elif defined(DUK_USE_PANIC_SEGFAULT)
-	            "segfaulting on purpose"
-#else
-#error no DUK_USE_PANIC_xxx macro defined
-#endif
-	            ")\n", (long) code, (const char *) (msg ? msg : "null"));
-	DUK_FFLUSH(DUK_STDERR);
-#else
-	/* omit print */
-	DUK_UNREF(code);
-	DUK_UNREF(msg);
-#endif
-
-#if defined(DUK_USE_PANIC_ABORT)
-	DUK_ABORT();
-#elif defined(DUK_USE_PANIC_EXIT)
-	DUK_EXIT(-1);
-#elif defined(DUK_USE_PANIC_SEGFAULT)
-	/* exit() afterwards to satisfy "noreturn" */
-	DUK_CAUSE_SEGFAULT();  /* SCANBUILD: "Dereference of null pointer", normal */
-	DUK_EXIT(-1);
-#else
-#error no DUK_USE_PANIC_xxx macro defined
-#endif
-
-	DUK_UNREACHABLE();
-}
-#endif  /* !DUK_USE_PANIC_HANDLER */
-
-#undef DUK__ERRFMT_BUFSIZE

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_error_misc.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_misc.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_misc.c
deleted file mode 100644
index 5b37855..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_misc.c
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- *  Error helpers
- */
-
-#include "duk_internal.h"
-
-/*
- *  Helper to walk the thread chain and see if there is an active error
- *  catcher.  Protected calls or finally blocks aren't considered catching.
- */
-
-#if defined(DUK_USE_DEBUGGER_SUPPORT) && \
-    (defined(DUK_USE_DEBUGGER_THROW_NOTIFY) || defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT))
-DUK_LOCAL duk_bool_t duk__have_active_catcher(duk_hthread *thr) {
-	/*
-	 * XXX: As noted above, a protected API call won't be counted as a
-	 * catcher. This is usually convenient, e.g. in the case of a top-
-	 * level duk_pcall(), but may not always be desirable. Perhaps add an
-	 * argument to treat them as catchers?
-	 */
-
-	duk_size_t i;
-
-	DUK_ASSERT(thr != NULL);
-
-	while (thr != NULL) {
-		for (i = 0; i < thr->catchstack_top; i++) {
-			duk_catcher *cat = thr->catchstack + i;
-			if (DUK_CAT_HAS_CATCH_ENABLED(cat)) {
-				return 1;  /* all we need to know */
-			}
-		}
-		thr = thr->resumer;
-	}
-	return 0;
-}
-#endif  /* DUK_USE_DEBUGGER_SUPPORT && (DUK_USE_DEBUGGER_THROW_NOTIFY || DUK_USE_DEBUGGER_PAUSE_UNCAUGHT) */
-
-/*
- *  Get prototype object for an integer error code.
- */
-
-DUK_INTERNAL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t code) {
-	switch (code) {
-	case DUK_ERR_EVAL_ERROR:
-		return thr->builtins[DUK_BIDX_EVAL_ERROR_PROTOTYPE];
-	case DUK_ERR_RANGE_ERROR:
-		return thr->builtins[DUK_BIDX_RANGE_ERROR_PROTOTYPE];
-	case DUK_ERR_REFERENCE_ERROR:
-		return thr->builtins[DUK_BIDX_REFERENCE_ERROR_PROTOTYPE];
-	case DUK_ERR_SYNTAX_ERROR:
-		return thr->builtins[DUK_BIDX_SYNTAX_ERROR_PROTOTYPE];
-	case DUK_ERR_TYPE_ERROR:
-		return thr->builtins[DUK_BIDX_TYPE_ERROR_PROTOTYPE];
-	case DUK_ERR_URI_ERROR:
-		return thr->builtins[DUK_BIDX_URI_ERROR_PROTOTYPE];
-
-	/* XXX: more specific error classes? */
-	case DUK_ERR_UNIMPLEMENTED_ERROR:
-	case DUK_ERR_INTERNAL_ERROR:
-	case DUK_ERR_ALLOC_ERROR:
-	case DUK_ERR_ASSERTION_ERROR:
-	case DUK_ERR_API_ERROR:
-	case DUK_ERR_ERROR:
-	default:
-		return thr->builtins[DUK_BIDX_ERROR_PROTOTYPE];
-	}
-}
-
-/*
- *  Exposed helper for setting up heap longjmp state.
- */
-
-DUK_INTERNAL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type) {
-#if defined(DUK_USE_DEBUGGER_SUPPORT)
-	/* If something is thrown with the debugger attached and nobody will
-	 * catch it, execution is paused before the longjmp, turning over
-	 * control to the debug client.  This allows local state to be examined
-	 * before the stack is unwound.  Errors are not intercepted when debug
-	 * message loop is active (e.g. for Eval).
-	 */
-
-	/* XXX: Allow customizing the pause and notify behavior at runtime
-	 * using debugger runtime flags.  For now the behavior is fixed using
-	 * config options.
-	 */
-#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY) || defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT)
-	if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) &&
-	    !thr->heap->dbg_processing &&
-	    lj_type == DUK_LJ_TYPE_THROW) {
-		duk_context *ctx = (duk_context *) thr;
-		duk_bool_t fatal;
-		duk_hobject *h_obj;
-
-		/* Don't intercept a DoubleError, we may have caused the initial double
-		 * fault and attempting to intercept it will cause us to be called
-		 * recursively and exhaust the C stack.
-		 */
-		h_obj = duk_get_hobject(ctx, -1);
-		if (h_obj == thr->builtins[DUK_BIDX_DOUBLE_ERROR]) {
-			DUK_D(DUK_DPRINT("built-in DoubleError instance thrown, not intercepting"));
-			goto skip_throw_intercept;
-		}
-
-		DUK_D(DUK_DPRINT("throw with debugger attached, report to client"));
-
-		fatal = !duk__have_active_catcher(thr);
-
-#if defined(DUK_USE_DEBUGGER_THROW_NOTIFY)
-		/* Report it to the debug client */
-		duk_debug_send_throw(thr, fatal);
-#endif
-
-#if defined(DUK_USE_DEBUGGER_PAUSE_UNCAUGHT)
-		if (fatal) {
-			DUK_D(DUK_DPRINT("throw will be fatal, halt before longjmp"));
-			duk_debug_halt_execution(thr, 1 /*use_prev_pc*/);
-		}
-#endif
-	}
-
- skip_throw_intercept:
-#endif  /* DUK_USE_DEBUGGER_THROW_NOTIFY || DUK_USE_DEBUGGER_PAUSE_UNCAUGHT */
-#endif  /* DUK_USE_DEBUGGER_SUPPORT */
-
-	thr->heap->lj.type = lj_type;
-
-	DUK_ASSERT(thr->valstack_top > thr->valstack);
-	DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value1, thr->valstack_top - 1);  /* side effects */
-
-	duk_pop((duk_context *) thr);
-}

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_error_throw.c
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_throw.c b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_throw.c
deleted file mode 100644
index 69b75f0..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_error_throw.c
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- *  Create and throw an Ecmascript error object based on a code and a message.
- *
- *  Used when we throw errors internally.  Ecmascript generated error objects
- *  are created by Ecmascript code, and the throwing is handled by the bytecode
- *  executor.
- */
-
-#include "duk_internal.h"
-
-/*
- *  Create and throw an error (originating from Duktape internally)
- *
- *  Push an error object on top of the stack, possibly throw augmenting
- *  the error, and finally longjmp.
- *
- *  If an error occurs while we're dealing with the current error, we might
- *  enter an infinite recursion loop.  This is prevented by detecting a
- *  "double fault" through the heap->handling_error flag; the recursion
- *  then stops at the second level.
- */
-
-#ifdef DUK_USE_VERBOSE_ERRORS
-DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code, const char *msg, const char *filename, duk_int_t line) {
-#else
-DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code) {
-#endif
-	duk_context *ctx = (duk_context *) thr;
-	duk_bool_t double_error = thr->heap->handling_error;
-
-#ifdef DUK_USE_VERBOSE_ERRORS
-	DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld, msg=%s, filename=%s, line=%ld",
-	                   (long) code, (const char *) msg,
-	                   (const char *) filename, (long) line));
-#else
-	DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld", (long) code));
-#endif
-
-	DUK_ASSERT(thr != NULL);
-	DUK_ASSERT(ctx != NULL);
-
-	thr->heap->handling_error = 1;
-
-	if (!double_error) {
-		/* Allow headroom for calls during error handling (see GH-191).
-		 * We allow space for 10 additional recursions, with one extra
-		 * for, e.g. a print() call at the deepest level.
-		 */
-		DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX);
-		thr->callstack_max = DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11;
-	}
-
-	DUK_ASSERT(thr->callstack_max == DUK_CALLSTACK_DEFAULT_MAX + DUK_CALLSTACK_GROW_STEP + 11);  /* just making sure */
-
-	/* Sync so that augmentation sees up-to-date activations, NULL
-	 * thr->ptr_curr_pc so that it's not used if side effects occur
-	 * in augmentation or longjmp handling.
-	 */
-	duk_hthread_sync_and_null_currpc(thr);
-
-	/*
-	 *  Create and push an error object onto the top of stack.
-	 *  If a "double error" occurs, use a fixed error instance
-	 *  to avoid further trouble.
-	 */
-
-	/* XXX: if attempt to push beyond allocated valstack, this double fault
-	 * handling fails miserably.  We should really write the double error
-	 * directly to thr->heap->lj.value1 and avoid valstack use entirely.
-	 */
-
-	if (double_error) {
-		if (thr->builtins[DUK_BIDX_DOUBLE_ERROR]) {
-			DUK_D(DUK_DPRINT("double fault detected -> push built-in fixed 'double error' instance"));
-			duk_push_hobject_bidx(ctx, DUK_BIDX_DOUBLE_ERROR);
-		} else {
-			DUK_D(DUK_DPRINT("double fault detected; there is no built-in fixed 'double error' instance "
-			                 "-> push the error code as a number"));
-			duk_push_int(ctx, (duk_int_t) code);
-		}
-	} else {
-		/* Error object is augmented at its creation here. */
-		duk_require_stack(ctx, 1);
-		/* XXX: unnecessary '%s' formatting here, but cannot use
-		 * 'msg' as a format string directly.
-		 */
-#ifdef DUK_USE_VERBOSE_ERRORS
-		duk_push_error_object_raw(ctx,
-		                          code | DUK_ERRCODE_FLAG_NOBLAME_FILELINE,
-		                          filename,
-		                          line,
-		                          "%s",
-		                          (const char *) msg);
-#else
-		duk_push_error_object_raw(ctx,
-		                          code | DUK_ERRCODE_FLAG_NOBLAME_FILELINE,
-		                          NULL,
-		                          0,
-		                          NULL);
-#endif
-	}
-
-	/*
-	 *  Augment error (throw time), unless alloc/double error
-	 */
-
-	if (double_error || code == DUK_ERR_ALLOC_ERROR) {
-		DUK_D(DUK_DPRINT("alloc or double error: skip throw augmenting to avoid further trouble"));
-	} else {
-#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-		DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT (before throw augment)",
-		                     (duk_tval *) duk_get_tval(ctx, -1)));
-		duk_err_augment_error_throw(thr);
-#endif
-	}
-
-	/*
-	 *  Finally, longjmp
-	 */
-
-	duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW);
-
-	thr->callstack_max = DUK_CALLSTACK_DEFAULT_MAX;  /* reset callstack limit */
-	thr->heap->handling_error = 0;
-
-	DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT, %!iT (after throw augment)",
-	                     (duk_tval *) &thr->heap->lj.value1, (duk_tval *) &thr->heap->lj.value2));
-
-	duk_err_longjmp(thr);
-	DUK_UNREACHABLE();
-}
-
-/*
- *  Helper for C function call negative return values.
- */
-
-DUK_INTERNAL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc) {
-	duk_context *ctx = (duk_context *) thr;
-	const char *msg;
-	duk_errcode_t code;
-
-	DUK_ASSERT(thr != NULL);
-	DUK_ASSERT(rc < 0);
-
-	/* XXX: this generates quite large code - perhaps select the error
-	 * class based on the code and then just use the error 'name'?
-	 */
-	/* XXX: shared strings */
-
-	code = -rc;
-
-	switch (rc) {
-	case DUK_RET_UNIMPLEMENTED_ERROR:  msg = "unimplemented"; break;
-	case DUK_RET_UNSUPPORTED_ERROR:    msg = "unsupported"; break;
-	case DUK_RET_INTERNAL_ERROR:       msg = "internal"; break;
-	case DUK_RET_ALLOC_ERROR:          msg = "alloc"; break;
-	case DUK_RET_ASSERTION_ERROR:      msg = "assertion"; break;
-	case DUK_RET_API_ERROR:            msg = "api"; break;
-	case DUK_RET_UNCAUGHT_ERROR:       msg = "uncaught"; break;
-	case DUK_RET_ERROR:                msg = "error"; break;
-	case DUK_RET_EVAL_ERROR:           msg = "eval"; break;
-	case DUK_RET_RANGE_ERROR:          msg = "range"; break;
-	case DUK_RET_REFERENCE_ERROR:      msg = "reference"; break;
-	case DUK_RET_SYNTAX_ERROR:         msg = "syntax"; break;
-	case DUK_RET_TYPE_ERROR:           msg = "type"; break;
-	case DUK_RET_URI_ERROR:            msg = "uri"; break;
-	default:                           msg = "unknown"; break;
-	}
-
-	DUK_ASSERT(msg != NULL);
-
-	/*
-	 *  The __FILE__ and __LINE__ information is intentionally not used in the
-	 *  creation of the error object, as it isn't useful in the tracedata.  The
-	 *  tracedata still contains the function which returned the negative return
-	 *  code, and having the file/line of this function isn't very useful.
-	 */
-
-	duk_error_raw(ctx, code, NULL, 0, "%s error (rc %ld)", (const char *) msg, (long) rc);
-	DUK_UNREACHABLE();
-}

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_exception.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_exception.h b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_exception.h
deleted file mode 100644
index 7df24de..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_exception.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
- *  Exception for Duktape internal throws when C++ exceptions are used
- *  for long control transfers.
- *
- *  Doesn't inherit from any exception base class to minimize the chance
- *  that user code would accidentally catch this exception.
- */
-
-#ifndef DUK_EXCEPTION_H_INCLUDED
-#define DUK_EXCEPTION_H_INCLUDED
-
-#if defined(DUK_USE_CPP_EXCEPTIONS)
-class duk_internal_exception {
-	/* intentionally empty */
-};
-#endif
-
-#endif  /* DUK_EXCEPTION_H_INCLUDED */

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_forwdecl.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_forwdecl.h b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_forwdecl.h
deleted file mode 100644
index 865d307..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_forwdecl.h
+++ /dev/null
@@ -1,122 +0,0 @@
-/*
- *  Forward declarations for all Duktape structures.
- */
-
-#ifndef DUK_FORWDECL_H_INCLUDED
-#define DUK_FORWDECL_H_INCLUDED
-
-/*
- *  Forward declarations
- */
-
-#if defined(DUK_USE_CPP_EXCEPTIONS)
-class duk_internal_exception;
-#else
-struct duk_jmpbuf;
-#endif
-
-/* duk_tval intentionally skipped */
-struct duk_heaphdr;
-struct duk_heaphdr_string;
-struct duk_hstring;
-struct duk_hstring_external;
-struct duk_hobject;
-struct duk_hcompiledfunction;
-struct duk_hnativefunction;
-struct duk_hthread;
-struct duk_hbufferobject;
-struct duk_hbuffer;
-struct duk_hbuffer_fixed;
-struct duk_hbuffer_dynamic;
-struct duk_hbuffer_external;
-
-struct duk_propaccessor;
-union duk_propvalue;
-struct duk_propdesc;
-
-struct duk_heap;
-struct duk_breakpoint;
-
-struct duk_activation;
-struct duk_catcher;
-struct duk_strcache;
-struct duk_ljstate;
-struct duk_strtab_entry;
-
-#ifdef DUK_USE_DEBUG
-struct duk_fixedbuffer;
-#endif
-
-struct duk_bitdecoder_ctx;
-struct duk_bitencoder_ctx;
-struct duk_bufwriter_ctx;
-
-struct duk_token;
-struct duk_re_token;
-struct duk_lexer_point;
-struct duk_lexer_ctx;
-struct duk_lexer_codepoint;
-
-struct duk_compiler_instr;
-struct duk_compiler_func;
-struct duk_compiler_ctx;
-
-struct duk_re_matcher_ctx;
-struct duk_re_compiler_ctx;
-
-#if defined(DUK_USE_CPP_EXCEPTIONS)
-/* no typedef */
-#else
-typedef struct duk_jmpbuf duk_jmpbuf;
-#endif
-
-/* duk_tval intentionally skipped */
-typedef struct duk_heaphdr duk_heaphdr;
-typedef struct duk_heaphdr_string duk_heaphdr_string;
-typedef struct duk_hstring duk_hstring;
-typedef struct duk_hstring_external duk_hstring_external;
-typedef struct duk_hobject duk_hobject;
-typedef struct duk_hcompiledfunction duk_hcompiledfunction;
-typedef struct duk_hnativefunction duk_hnativefunction;
-typedef struct duk_hbufferobject duk_hbufferobject;
-typedef struct duk_hthread duk_hthread;
-typedef struct duk_hbuffer duk_hbuffer;
-typedef struct duk_hbuffer_fixed duk_hbuffer_fixed;
-typedef struct duk_hbuffer_dynamic duk_hbuffer_dynamic;
-typedef struct duk_hbuffer_external duk_hbuffer_external;
-
-typedef struct duk_propaccessor duk_propaccessor;
-typedef union duk_propvalue duk_propvalue;
-typedef struct duk_propdesc duk_propdesc;
-
-typedef struct duk_heap duk_heap;
-typedef struct duk_breakpoint duk_breakpoint;
-
-typedef struct duk_activation duk_activation;
-typedef struct duk_catcher duk_catcher;
-typedef struct duk_strcache duk_strcache;
-typedef struct duk_ljstate duk_ljstate;
-typedef struct duk_strtab_entry duk_strtab_entry;
-
-#ifdef DUK_USE_DEBUG
-typedef struct duk_fixedbuffer duk_fixedbuffer;
-#endif
-
-typedef struct duk_bitdecoder_ctx duk_bitdecoder_ctx;
-typedef struct duk_bitencoder_ctx duk_bitencoder_ctx;
-typedef struct duk_bufwriter_ctx duk_bufwriter_ctx;
-
-typedef struct duk_token duk_token;
-typedef struct duk_re_token duk_re_token;
-typedef struct duk_lexer_point duk_lexer_point;
-typedef struct duk_lexer_ctx duk_lexer_ctx;
-typedef struct duk_lexer_codepoint duk_lexer_codepoint;
-
-typedef struct duk_compiler_instr duk_compiler_instr;
-typedef struct duk_compiler_func duk_compiler_func;
-typedef struct duk_compiler_ctx duk_compiler_ctx;
-
-typedef struct duk_re_matcher_ctx duk_re_matcher_ctx;
-typedef struct duk_re_compiler_ctx duk_re_compiler_ctx;
-
-#endif  /* DUK_FORWDECL_H_INCLUDED */

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_hbuffer.h
----------------------------------------------------------------------
diff --git a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer.h b/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer.h
deleted file mode 100644
index e9417c0..0000000
--- a/thirdparty/civetweb-1.9.1/src/third_party/duktape-1.5.2/src-separate/duk_hbuffer.h
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- *  Heap buffer representation.
- *
- *  Heap allocated user data buffer which is either:
- *
- *    1. A fixed size buffer (data follows header statically)
- *    2. A dynamic size buffer (data pointer follows header)
- *
- *  The data pointer for a variable size buffer of zero size may be NULL.
- */
-
-#ifndef DUK_HBUFFER_H_INCLUDED
-#define DUK_HBUFFER_H_INCLUDED
-
-/*
- *  Flags
- *
- *  Fixed buffer:     0
- *  Dynamic buffer:   DUK_HBUFFER_FLAG_DYNAMIC
- *  External buffer:  DUK_HBUFFER_FLAG_DYNAMIC | DUK_HBUFFER_FLAG_EXTERNAL
- */
-
-#define DUK_HBUFFER_FLAG_DYNAMIC                  DUK_HEAPHDR_USER_FLAG(0)    /* buffer is behind a pointer, dynamic or external */
-#define DUK_HBUFFER_FLAG_EXTERNAL                 DUK_HEAPHDR_USER_FLAG(1)    /* buffer pointer is to an externally allocated buffer */
-
-#define DUK_HBUFFER_HAS_DYNAMIC(x)                DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
-#define DUK_HBUFFER_HAS_EXTERNAL(x)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
-
-#define DUK_HBUFFER_SET_DYNAMIC(x)                DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
-#define DUK_HBUFFER_SET_EXTERNAL(x)               DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
-
-#define DUK_HBUFFER_CLEAR_DYNAMIC(x)              DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
-#define DUK_HBUFFER_CLEAR_EXTERNAL(x)             DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
-
-/*
- *  Misc defines
- */
-
-/* Impose a maximum buffer length for now.  Restricted artificially to
- * ensure resize computations or adding a heap header length won't
- * overflow size_t and that a signed duk_int_t can hold a buffer
- * length.  The limit should be synchronized with DUK_HSTRING_MAX_BYTELEN.
- */
-
-#if defined(DUK_USE_BUFLEN16)
-#define DUK_HBUFFER_MAX_BYTELEN                   (0x0000ffffUL)
-#else
-/* Intentionally not 0x7fffffffUL; at least JSON code expects that
- * 2*len + 2 fits in 32 bits.
- */
-#define DUK_HBUFFER_MAX_BYTELEN                   (0x7ffffffeUL)
-#endif
-
-/*
- *  Field access
- */
-
-/* Get/set the current user visible size, without accounting for a dynamic
- * buffer's "spare" (= usable size).
- */
-#if defined(DUK_USE_BUFLEN16)
-/* size stored in duk_heaphdr unused flag bits */
-#define DUK_HBUFFER_GET_SIZE(x)     ((x)->hdr.h_flags >> 16)
-#define DUK_HBUFFER_SET_SIZE(x,v)   do { \
-		duk_size_t duk__v; \
-		duk__v = (v); \
-		DUK_ASSERT(duk__v <= 0xffffUL); \
-		(x)->hdr.h_flags = ((x)->hdr.h_flags & 0x0000ffffUL) | (((duk_uint32_t) duk__v) << 16); \
-	} while (0)
-#define DUK_HBUFFER_ADD_SIZE(x,dv)  do { \
-		(x)->hdr.h_flags += ((dv) << 16); \
-	} while (0)
-#define DUK_HBUFFER_SUB_SIZE(x,dv)  do { \
-		(x)->hdr.h_flags -= ((dv) << 16); \
-	} while (0)
-#else
-#define DUK_HBUFFER_GET_SIZE(x)     (((duk_hbuffer *) (x))->size)
-#define DUK_HBUFFER_SET_SIZE(x,v)   do { \
-		((duk_hbuffer *) (x))->size = (v); \
-	} while (0)
-#define DUK_HBUFFER_ADD_SIZE(x,dv)  do { \
-		(x)->size += (dv); \
-	} while (0)
-#define DUK_HBUFFER_SUB_SIZE(x,dv)  do { \
-		(x)->size -= (dv); \
-	} while (0)
-#endif
-
-#define DUK_HBUFFER_FIXED_GET_SIZE(x)       DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
-#define DUK_HBUFFER_FIXED_SET_SIZE(x,v)     DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x))
-
-#define DUK_HBUFFER_DYNAMIC_GET_SIZE(x)     DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
-#define DUK_HBUFFER_DYNAMIC_SET_SIZE(x,v)   DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))
-#define DUK_HBUFFER_DYNAMIC_ADD_SIZE(x,dv)  DUK_HBUFFER_ADD_SIZE((duk_hbuffer *) (x), (dv))
-#define DUK_HBUFFER_DYNAMIC_SUB_SIZE(x,dv)  DUK_HBUFFER_SUB_SIZE((duk_hbuffer *) (x), (dv))
-
-#define DUK_HBUFFER_EXTERNAL_GET_SIZE(x)    DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
-#define DUK_HBUFFER_EXTERNAL_SET_SIZE(x,v)  DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))
-
-#define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap,x)    ((duk_uint8_t *) (((duk_hbuffer_fixed *) (x)) + 1))
-
-#if defined(DUK_USE_HEAPPTR16)
-#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x) \
-	((void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, ((duk_heaphdr *) (x))->h_extra16))
-#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v)     do { \
-		((duk_heaphdr *) (x))->h_extra16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
-	} while (0)
-#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x)  do { \
-		((duk_heaphdr *) (x))->h_extra16 = 0;  /* assume 0 <=> NULL */ \
-	} while (0)
-#else
-#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x)       ((x)->curr_alloc)
-#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v)     do { \
-		(x)->curr_alloc = (void *) (v); \
-	} while (0)
-#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x)  do { \
-		(x)->curr_alloc = (void *) NULL; \
-	} while (0)
-#endif
-
-/* No pointer compression because pointer is potentially outside of
- * Duktape heap.
- */
-#if defined(DUK_USE_HEAPPTR16)
-#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap,x) \
-	((void *) (x)->curr_alloc)
-#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v)     do { \
-		(x)->curr_alloc = (void *) (v); \
-	} while (0)
-#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x)  do { \
-		(x)->curr_alloc = (void *) NULL; \
-	} while (0)
-#else
-#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap,x) \
-	((void *) (x)->curr_alloc)
-#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v)     do { \
-		(x)->curr_alloc = (void *) (v); \
-	} while (0)
-#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x)  do { \
-		(x)->curr_alloc = (void *) NULL; \
-	} while (0)
-#endif
-
-/* Get a pointer to the current buffer contents (matching current allocation
- * size).  May be NULL for zero size dynamic/external buffer.
- */
-#if defined(DUK_USE_HEAPPTR16)
-#define DUK_HBUFFER_GET_DATA_PTR(heap,x)  ( \
-	DUK_HBUFFER_HAS_DYNAMIC((x)) ? \
-		( \
-			DUK_HBUFFER_HAS_EXTERNAL((x)) ? \
-				DUK_HBUFFER_EXTERNAL_GET_DATA_PTR((heap), (duk_hbuffer_external *) (x)) : \
-				DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) \
-		) : \
-		DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \
-	)
-#else
-/* Without heap pointer compression duk_hbuffer_dynamic and duk_hbuffer_external
- * have the same layout so checking for fixed vs. dynamic (or external) is enough.
- */
-#define DUK_HBUFFER_GET_DATA_PTR(heap,x)  ( \
-	DUK_HBUFFER_HAS_DYNAMIC((x)) ? \
-		DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) : \
-		DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \
-	)
-#endif
-
-/*
- *  Structs
- */
-
-/* Shared prefix for all buffer types. */
-struct duk_hbuffer {
-	duk_heaphdr hdr;
-
-	/* It's not strictly necessary to track the current size, but
-	 * it is useful for writing robust native code.
-	 */
-
-	/* Current size (not counting a dynamic buffer's "spare"). */
-#if defined(DUK_USE_BUFLEN16)
-	/* Stored in duk_heaphdr unused flags. */
-#else
-	duk_size_t size;
-#endif
-
-	/*
-	 *  Data following the header depends on the DUK_HBUFFER_FLAG_DYNAMIC
-	 *  flag.
-	 *
-	 *  If the flag is clear (the buffer is a fixed size one), the buffer
-	 *  data follows the header directly, consisting of 'size' bytes.
-	 *
-	 *  If the flag is set, the actual buffer is allocated separately, and
-	 *  a few control fields follow the header.  Specifically:
-	 *
-	 *    - a "void *" pointing to the current allocation
-	 *    - a duk_size_t indicating the full allocated size (always >= 'size')
-	 *
-	 *  If DUK_HBUFFER_FLAG_EXTERNAL is set, the buffer has been allocated
-	 *  by user code, so that Duktape won't be able to resize it and won't
-	 *  free it.  This allows buffers to point to e.g. an externally
-	 *  allocated structure such as a frame buffer.
-	 *
-	 *  Unlike strings, no terminator byte (NUL) is guaranteed after the
-	 *  data.  This would be convenient, but would pad aligned user buffers
-	 *  unnecessarily upwards in size.  For instance, if user code requested
-	 *  a 64-byte dynamic buffer, 65 bytes would actually be allocated which
-	 *  would then potentially round upwards to perhaps 68 or 72 bytes.
-	 */
-};
-
-/* Fixed buffer; data follows struct, with proper alignment guaranteed by
- * struct size.
- */
-#if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_MSVC_PRAGMA)
-#pragma pack(push, 8)
-#endif
-struct duk_hbuffer_fixed {
-	/* A union is used here as a portable struct size / alignment trick:
-	 * by adding a 32-bit or a 64-bit (unused) union member, the size of
-	 * the struct is effectively forced to be a multiple of 4 or 8 bytes
-	 * (respectively) without increasing the size of the struct unless
-	 * necessary.
-	 */
-	union {
-		struct {
-			duk_heaphdr hdr;
-#if defined(DUK_USE_BUFLEN16)
-			/* Stored in duk_heaphdr unused flags. */
-#else
-			duk_size_t size;
-#endif
-		} s;
-#if (DUK_USE_ALIGN_BY == 4)
-		duk_uint32_t dummy_for_align4;
-#elif (DUK_USE_ALIGN_BY == 8)
-		duk_double_t dummy_for_align8;
-#elif (DUK_USE_ALIGN_BY == 1)
-		/* no extra padding */
-#else
-#error invalid DUK_USE_ALIGN_BY
-#endif
-	} u;
-
-	/*
-	 *  Data follows the struct header.  The struct size is padded by the
-	 *  compiler based on the struct members.  This guarantees that the
-	 *  buffer data will be aligned-by-4 but not necessarily aligned-by-8.
-	 *
-	 *  On platforms where alignment does not matter, the struct padding
-	 *  could be removed (if there is any).  On platforms where alignment
-	 *  by 8 is required, the struct size must be forced to be a multiple
-	 *  of 8 by some means.  Without it, some user code may break, and also
-	 *  Duktape itself breaks (e.g. the compiler stores duk_tvals in a
-	 *  dynamic buffer).
-	 */
-}
-#if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_GCC_ATTR)
-__attribute__ ((aligned (8)))
-#elif (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_CLANG_ATTR)
-__attribute__ ((aligned (8)))
-#endif
-;
-#if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_MSVC_PRAGMA)
-#pragma pack(pop)
-#endif
-
-/* Dynamic buffer with 'curr_alloc' pointing to a dynamic area allocated using
- * heap allocation primitives.  Also used for external buffers when low memory
- * options are not used.
- */
-struct duk_hbuffer_dynamic {
-	duk_heaphdr hdr;
-
-#if defined(DUK_USE_BUFLEN16)
-	/* Stored in duk_heaphdr unused flags. */
-#else
-	duk_size_t size;
-#endif
-
-#if defined(DUK_USE_HEAPPTR16)
-	/* Stored in duk_heaphdr h_extra16. */
-#else
-	void *curr_alloc;  /* may be NULL if alloc_size == 0 */
-#endif
-
-	/*
-	 *  Allocation size for 'curr_alloc' is alloc_size.  There is no
-	 *  automatic NUL terminator for buffers (see above for rationale).
-	 *
-	 *  'curr_alloc' is explicitly allocated with heap allocation
-	 *  primitives and will thus always have alignment suitable for
-	 *  e.g. duk_tval and an IEEE double.
-	 */
-};
-
-/* External buffer with 'curr_alloc' managed by user code and pointing to an
- * arbitrary address.  When heap pointer compression is not used, this struct
- * has the same layout as duk_hbuffer_dynamic.
- */
-struct duk_hbuffer_external {
-	duk_heaphdr hdr;
-
-#if defined(DUK_USE_BUFLEN16)
-	/* Stored in duk_heaphdr unused flags. */
-#else
-	duk_size_t size;
-#endif
-
-	/* Cannot be compressed as a heap pointer because may point to
-	 * an arbitrary address.
-	 */
-	void *curr_alloc;  /* may be NULL if alloc_size == 0 */
-};
-
-/*
- *  Prototypes
- */
-
-DUK_INTERNAL_DECL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags, void **out_bufdata);
-DUK_INTERNAL_DECL void *duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud);  /* indirect allocs */
-
-/* dynamic buffer ops */
-DUK_INTERNAL_DECL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size);
-DUK_INTERNAL_DECL void duk_hbuffer_reset(duk_hthread *thr, duk_hbuffer_dynamic *buf);
-
-#endif  /* DUK_HBUFFER_H_INCLUDED */


Mime
View raw message