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_hstring.h ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hstring.h b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hstring.h deleted file mode 100644 index f80ec34..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hstring.h +++ /dev/null @@ -1,219 +0,0 @@ -/* - * Heap string representation. - * - * Strings are byte sequences ordinarily stored in extended UTF-8 format, - * allowing values larger than the official UTF-8 range (used internally) - * and also allowing UTF-8 encoding of surrogate pairs (CESU-8 format). - * Strings may also be invalid UTF-8 altogether which is the case e.g. with - * strings used as internal property names and raw buffers converted to - * strings. In such cases the 'clen' field contains an inaccurate value. - * - * Ecmascript requires support for 32-bit long strings. However, since each - * 16-bit codepoint can take 3 bytes in CESU-8, this representation can only - * support about 1.4G codepoint long strings in extreme cases. This is not - * really a practical issue. - */ - -#ifndef DUK_HSTRING_H_INCLUDED -#define DUK_HSTRING_H_INCLUDED - -/* Impose a maximum string length for now. Restricted artificially to - * ensure adding a heap header length won't overflow size_t. The limit - * should be synchronized with DUK_HBUFFER_MAX_BYTELEN. - * - * E5.1 makes provisions to support strings longer than 4G characters. - * This limit should be eliminated on 64-bit platforms (and increased - * closer to maximum support on 32-bit platforms). - */ - -#if defined(DUK_USE_STRLEN16) -#define DUK_HSTRING_MAX_BYTELEN (0x0000ffffUL) -#else -#define DUK_HSTRING_MAX_BYTELEN (0x7fffffffUL) -#endif - -/* XXX: could add flags for "is valid CESU-8" (Ecmascript compatible strings), - * "is valid UTF-8", "is valid extended UTF-8" (internal strings are not, - * regexp bytecode is), and "contains non-BMP characters". These are not - * needed right now. - */ - -#define DUK_HSTRING_FLAG_ASCII DUK_HEAPHDR_USER_FLAG(0) /* string is ASCII, clen == blen */ -#define DUK_HSTRING_FLAG_ARRIDX DUK_HEAPHDR_USER_FLAG(1) /* string is a valid array index */ -#define DUK_HSTRING_FLAG_INTERNAL DUK_HEAPHDR_USER_FLAG(2) /* string is internal */ -#define DUK_HSTRING_FLAG_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(3) /* string is a reserved word (non-strict) */ -#define DUK_HSTRING_FLAG_STRICT_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(4) /* string is a reserved word (strict) */ -#define DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS DUK_HEAPHDR_USER_FLAG(5) /* string is 'eval' or 'arguments' */ -#define DUK_HSTRING_FLAG_EXTDATA DUK_HEAPHDR_USER_FLAG(6) /* string data is external (duk_hstring_external) */ - -#define DUK_HSTRING_HAS_ASCII(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII) -#define DUK_HSTRING_HAS_ARRIDX(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX) -#define DUK_HSTRING_HAS_INTERNAL(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL) -#define DUK_HSTRING_HAS_RESERVED_WORD(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD) -#define DUK_HSTRING_HAS_STRICT_RESERVED_WORD(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD) -#define DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS) -#define DUK_HSTRING_HAS_EXTDATA(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA) - -#define DUK_HSTRING_SET_ASCII(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII) -#define DUK_HSTRING_SET_ARRIDX(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX) -#define DUK_HSTRING_SET_INTERNAL(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL) -#define DUK_HSTRING_SET_RESERVED_WORD(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD) -#define DUK_HSTRING_SET_STRICT_RESERVED_WORD(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD) -#define DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS) -#define DUK_HSTRING_SET_EXTDATA(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA) - -#define DUK_HSTRING_CLEAR_ASCII(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII) -#define DUK_HSTRING_CLEAR_ARRIDX(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX) -#define DUK_HSTRING_CLEAR_INTERNAL(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL) -#define DUK_HSTRING_CLEAR_RESERVED_WORD(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD) -#define DUK_HSTRING_CLEAR_STRICT_RESERVED_WORD(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD) -#define DUK_HSTRING_CLEAR_EVAL_OR_ARGUMENTS(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS) -#define DUK_HSTRING_CLEAR_EXTDATA(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA) - -#if 0 /* Slightly smaller code without explicit flag, but explicit flag - * is very useful when 'clen' is dropped. - */ -#define DUK_HSTRING_IS_ASCII(x) (DUK_HSTRING_GET_BYTELEN((x)) == DUK_HSTRING_GET_CHARLEN((x))) -#endif -#define DUK_HSTRING_IS_ASCII(x) DUK_HSTRING_HAS_ASCII((x)) -#define DUK_HSTRING_IS_EMPTY(x) (DUK_HSTRING_GET_BYTELEN((x)) == 0) - -#if defined(DUK_USE_STRHASH16) -#define DUK_HSTRING_GET_HASH(x) ((x)->hdr.h_flags >> 16) -#define DUK_HSTRING_SET_HASH(x,v) do { \ - (x)->hdr.h_flags = ((x)->hdr.h_flags & 0x0000ffffUL) | ((v) << 16); \ - } while (0) -#else -#define DUK_HSTRING_GET_HASH(x) ((x)->hash) -#define DUK_HSTRING_SET_HASH(x,v) do { \ - (x)->hash = (v); \ - } while (0) -#endif - -#if defined(DUK_USE_STRLEN16) -#define DUK_HSTRING_GET_BYTELEN(x) ((x)->hdr.h_strextra16) -#define DUK_HSTRING_SET_BYTELEN(x,v) do { \ - (x)->hdr.h_strextra16 = (v); \ - } while (0) -#if defined(DUK_USE_HSTRING_CLEN) -#define DUK_HSTRING_GET_CHARLEN(x) ((x)->clen16) -#define DUK_HSTRING_SET_CHARLEN(x,v) do { \ - (x)->clen16 = (v); \ - } while (0) -#else -#define DUK_HSTRING_GET_CHARLEN(x) duk_hstring_get_charlen((x)) -#define DUK_HSTRING_SET_CHARLEN(x,v) do { \ - DUK_ASSERT(0); /* should never be called */ \ - } while (0) -#endif -#else -#define DUK_HSTRING_GET_BYTELEN(x) ((x)->blen) -#define DUK_HSTRING_SET_BYTELEN(x,v) do { \ - (x)->blen = (v); \ - } while (0) -#define DUK_HSTRING_GET_CHARLEN(x) ((x)->clen) -#define DUK_HSTRING_SET_CHARLEN(x,v) do { \ - (x)->clen = (v); \ - } while (0) -#endif - -#if defined(DUK_USE_HSTRING_EXTDATA) -#define DUK_HSTRING_GET_EXTDATA(x) \ - ((x)->extdata) -#define DUK_HSTRING_GET_DATA(x) \ - (DUK_HSTRING_HAS_EXTDATA((x)) ? \ - DUK_HSTRING_GET_EXTDATA((const duk_hstring_external *) (x)) : ((const duk_uint8_t *) ((x) + 1))) -#else -#define DUK_HSTRING_GET_DATA(x) \ - ((const duk_uint8_t *) ((x) + 1)) -#endif - -#define DUK_HSTRING_GET_DATA_END(x) \ - (DUK_HSTRING_GET_DATA((x)) + (x)->blen) - -/* marker value; in E5 2^32-1 is not a valid array index (2^32-2 is highest valid) */ -#define DUK_HSTRING_NO_ARRAY_INDEX (0xffffffffUL) - -/* get array index related to string (or return DUK_HSTRING_NO_ARRAY_INDEX); - * avoids helper call if string has no array index value. - */ -#define DUK_HSTRING_GET_ARRIDX_FAST(h) \ - (DUK_HSTRING_HAS_ARRIDX((h)) ? duk_js_to_arrayindex_string_helper((h)) : DUK_HSTRING_NO_ARRAY_INDEX) - -/* slower but more compact variant */ -#define DUK_HSTRING_GET_ARRIDX_SLOW(h) \ - (duk_js_to_arrayindex_string_helper((h))) - -/* - * Misc - */ - -struct duk_hstring { - /* Smaller heaphdr than for other objects, because strings are held - * in string intern table which requires no link pointers. Much of - * the 32-bit flags field is unused by flags, so we can stuff a 16-bit - * field in there. - */ - duk_heaphdr_string hdr; - - /* Note: we could try to stuff a partial hash (e.g. 16 bits) into the - * shared heap header. Good hashing needs more hash bits though. - */ - - /* string hash */ -#if defined(DUK_USE_STRHASH16) - /* If 16-bit hash is in use, stuff it into duk_heaphdr_string flags. */ -#else - duk_uint32_t hash; -#endif - - /* length in bytes (not counting NUL term) */ -#if defined(DUK_USE_STRLEN16) - /* placed in duk_heaphdr_string */ -#else - duk_uint32_t blen; -#endif - - /* length in codepoints (must be E5 compatible) */ -#if defined(DUK_USE_STRLEN16) -#if defined(DUK_USE_HSTRING_CLEN) - duk_uint16_t clen16; -#else - /* computed live */ -#endif -#else - duk_uint32_t clen; -#endif - - /* - * String value of 'blen+1' bytes follows (+1 for NUL termination - * convenience for C API). No alignment needs to be guaranteed - * for strings, but fields above should guarantee alignment-by-4 - * (but not alignment-by-8). - */ -}; - -/* The external string struct is defined even when the feature is inactive. */ -struct duk_hstring_external { - duk_hstring str; - - /* - * For an external string, the NUL-terminated string data is stored - * externally. The user must guarantee that data behind this pointer - * doesn't change while it's used. - */ - - const duk_uint8_t *extdata; -}; - -/* - * Prototypes - */ - -DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr, duk_hstring *h, duk_uint_t pos); - -#if !defined(DUK_USE_HSTRING_CLEN) -DUK_INTERNAL_DECL duk_size_t duk_hstring_get_charlen(duk_hstring *h); -#endif - -#endif /* DUK_HSTRING_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_hstring_misc.c ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hstring_misc.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hstring_misc.c deleted file mode 100644 index b685147..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hstring_misc.c +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Misc support functions - */ - -#include "duk_internal.h" - -DUK_INTERNAL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr, duk_hstring *h, duk_uint_t pos) { - duk_uint32_t boff; - const duk_uint8_t *p, *p_start, *p_end; - duk_ucodepoint_t cp; - - /* Caller must check character offset to be inside the string. */ - DUK_ASSERT(thr != NULL); - DUK_ASSERT(h != NULL); - DUK_ASSERT_DISABLE(pos >= 0); /* unsigned */ - DUK_ASSERT(pos < (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h)); - - boff = duk_heap_strcache_offset_char2byte(thr, h, (duk_uint32_t) pos); - DUK_DDD(DUK_DDDPRINT("charCodeAt: pos=%ld -> boff=%ld, str=%!O", - (long) pos, (long) boff, (duk_heaphdr *) h)); - DUK_ASSERT_DISABLE(boff >= 0); - DUK_ASSERT(boff < DUK_HSTRING_GET_BYTELEN(h)); - - p_start = DUK_HSTRING_GET_DATA(h); - p_end = p_start + DUK_HSTRING_GET_BYTELEN(h); - p = p_start + boff; - DUK_DDD(DUK_DDDPRINT("p_start=%p, p_end=%p, p=%p", - (const void *) p_start, (const void *) p_end, - (const void *) p)); - - /* This may throw an error though not for valid E5 strings. */ - cp = duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end); - return cp; -} - -#if !defined(DUK_USE_HSTRING_CLEN) -DUK_INTERNAL duk_size_t duk_hstring_get_charlen(duk_hstring *h) { - if (DUK_HSTRING_HAS_ASCII(h)) { - /* Most practical strings will go here. */ - return DUK_HSTRING_GET_BYTELEN(h); - } else { - return duk_unicode_unvalidated_utf8_length(DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h)); - } -} -#endif /* !DUK_USE_HSTRING_CLEN */ 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_hthread.h ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread.h b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread.h deleted file mode 100644 index d904c64..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread.h +++ /dev/null @@ -1,380 +0,0 @@ -/* - * Heap thread object representation. - * - * duk_hthread is also the 'context' (duk_context) for exposed APIs - * which mostly operate on the topmost frame of the value stack. - */ - -#ifndef DUK_HTHREAD_H_INCLUDED -#define DUK_HTHREAD_H_INCLUDED - -/* - * Stack constants - */ - -#define DUK_VALSTACK_GROW_STEP 128 /* roughly 1 kiB */ -#define DUK_VALSTACK_SHRINK_THRESHOLD 256 /* roughly 2 kiB */ -#define DUK_VALSTACK_SHRINK_SPARE 64 /* roughly 0.5 kiB */ -#define DUK_VALSTACK_INITIAL_SIZE 128 /* roughly 1.0 kiB -> but rounds up to DUK_VALSTACK_GROW_STEP in practice */ -#define DUK_VALSTACK_INTERNAL_EXTRA 64 /* internal extra elements assumed on function entry, - * always added to user-defined 'extra' for e.g. the - * duk_check_stack() call. - */ -#define DUK_VALSTACK_API_ENTRY_MINIMUM DUK_API_ENTRY_STACK - /* number of elements guaranteed to be user accessible - * (in addition to call arguments) on Duktape/C function entry. - */ - -/* Note: DUK_VALSTACK_INITIAL_SIZE must be >= DUK_VALSTACK_API_ENTRY_MINIMUM - * + DUK_VALSTACK_INTERNAL_EXTRA so that the initial stack conforms to spare - * requirements. - */ - -#define DUK_VALSTACK_DEFAULT_MAX 1000000L - -#define DUK_CALLSTACK_GROW_STEP 8 /* roughly 256 bytes */ -#define DUK_CALLSTACK_SHRINK_THRESHOLD 16 /* roughly 512 bytes */ -#define DUK_CALLSTACK_SHRINK_SPARE 8 /* roughly 256 bytes */ -#define DUK_CALLSTACK_INITIAL_SIZE 8 -#define DUK_CALLSTACK_DEFAULT_MAX 10000L - -#define DUK_CATCHSTACK_GROW_STEP 4 /* roughly 64 bytes */ -#define DUK_CATCHSTACK_SHRINK_THRESHOLD 8 /* roughly 128 bytes */ -#define DUK_CATCHSTACK_SHRINK_SPARE 4 /* roughly 64 bytes */ -#define DUK_CATCHSTACK_INITIAL_SIZE 4 -#define DUK_CATCHSTACK_DEFAULT_MAX 10000L - -/* - * Activation defines - */ - -#define DUK_ACT_FLAG_STRICT (1 << 0) /* function executes in strict mode */ -#define DUK_ACT_FLAG_TAILCALLED (1 << 1) /* activation has tail called one or more times */ -#define DUK_ACT_FLAG_CONSTRUCT (1 << 2) /* function executes as a constructor (called via "new") */ -#define DUK_ACT_FLAG_PREVENT_YIELD (1 << 3) /* activation prevents yield (native call or "new") */ -#define DUK_ACT_FLAG_DIRECT_EVAL (1 << 4) /* activation is a direct eval call */ -#define DUK_ACT_FLAG_BREAKPOINT_ACTIVE (1 << 5) /* activation has active breakpoint(s) */ - -#define DUK_ACT_GET_FUNC(act) ((act)->func) - -/* - * Flags for __FILE__ / __LINE__ registered into tracedata - */ - -#define DUK_TB_FLAG_NOBLAME_FILELINE (1 << 0) /* don't report __FILE__ / __LINE__ as fileName/lineNumber */ - -/* - * Catcher defines - */ - -/* flags field: LLLLLLFT, L = label (24 bits), F = flags (4 bits), T = type (4 bits) */ -#define DUK_CAT_TYPE_MASK 0x0000000fUL -#define DUK_CAT_TYPE_BITS 4 -#define DUK_CAT_LABEL_MASK 0xffffff00UL -#define DUK_CAT_LABEL_BITS 24 -#define DUK_CAT_LABEL_SHIFT 8 - -#define DUK_CAT_FLAG_CATCH_ENABLED (1 << 4) /* catch part will catch */ -#define DUK_CAT_FLAG_FINALLY_ENABLED (1 << 5) /* finally part will catch */ -#define DUK_CAT_FLAG_CATCH_BINDING_ENABLED (1 << 6) /* request to create catch binding */ -#define DUK_CAT_FLAG_LEXENV_ACTIVE (1 << 7) /* catch or with binding is currently active */ - -#define DUK_CAT_TYPE_UNKNOWN 0 -#define DUK_CAT_TYPE_TCF 1 -#define DUK_CAT_TYPE_LABEL 2 - -#define DUK_CAT_GET_TYPE(c) ((c)->flags & DUK_CAT_TYPE_MASK) -#define DUK_CAT_GET_LABEL(c) (((c)->flags & DUK_CAT_LABEL_MASK) >> DUK_CAT_LABEL_SHIFT) - -#define DUK_CAT_HAS_CATCH_ENABLED(c) ((c)->flags & DUK_CAT_FLAG_CATCH_ENABLED) -#define DUK_CAT_HAS_FINALLY_ENABLED(c) ((c)->flags & DUK_CAT_FLAG_FINALLY_ENABLED) -#define DUK_CAT_HAS_CATCH_BINDING_ENABLED(c) ((c)->flags & DUK_CAT_FLAG_CATCH_BINDING_ENABLED) -#define DUK_CAT_HAS_LEXENV_ACTIVE(c) ((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE) - -#define DUK_CAT_SET_CATCH_ENABLED(c) do { \ - (c)->flags |= DUK_CAT_FLAG_CATCH_ENABLED; \ - } while (0) -#define DUK_CAT_SET_FINALLY_ENABLED(c) do { \ - (c)->flags |= DUK_CAT_FLAG_FINALLY_ENABLED; \ - } while (0) -#define DUK_CAT_SET_CATCH_BINDING_ENABLED(c) do { \ - (c)->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \ - } while (0) -#define DUK_CAT_SET_LEXENV_ACTIVE(c) do { \ - (c)->flags |= DUK_CAT_FLAG_LEXENV_ACTIVE; \ - } while (0) - -#define DUK_CAT_CLEAR_CATCH_ENABLED(c) do { \ - (c)->flags &= ~DUK_CAT_FLAG_CATCH_ENABLED; \ - } while (0) -#define DUK_CAT_CLEAR_FINALLY_ENABLED(c) do { \ - (c)->flags &= ~DUK_CAT_FLAG_FINALLY_ENABLED; \ - } while (0) -#define DUK_CAT_CLEAR_CATCH_BINDING_ENABLED(c) do { \ - (c)->flags &= ~DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \ - } while (0) -#define DUK_CAT_CLEAR_LEXENV_ACTIVE(c) do { \ - (c)->flags &= ~DUK_CAT_FLAG_LEXENV_ACTIVE; \ - } while (0) - -/* - * Thread defines - */ - -#if defined(DUK_USE_ROM_STRINGS) -#define DUK_HTHREAD_GET_STRING(thr,idx) \ - ((duk_hstring *) DUK_LOSE_CONST(duk_rom_strings_stridx[(idx)])) -#else /* DUK_USE_ROM_STRINGS */ -#if defined(DUK_USE_HEAPPTR16) -#define DUK_HTHREAD_GET_STRING(thr,idx) \ - ((duk_hstring *) DUK_USE_HEAPPTR_DEC16((thr)->heap->heap_udata, (thr)->strs16[(idx)])) -#else -#define DUK_HTHREAD_GET_STRING(thr,idx) \ - ((thr)->strs[(idx)]) -#endif -#endif /* DUK_USE_ROM_STRINGS */ - -#define DUK_HTHREAD_GET_CURRENT_ACTIVATION(thr) (&(thr)->callstack[(thr)->callstack_top - 1]) - -/* values for the state field */ -#define DUK_HTHREAD_STATE_INACTIVE 1 /* thread not currently running */ -#define DUK_HTHREAD_STATE_RUNNING 2 /* thread currently running (only one at a time) */ -#define DUK_HTHREAD_STATE_RESUMED 3 /* thread resumed another thread (active but not running) */ -#define DUK_HTHREAD_STATE_YIELDED 4 /* thread has yielded */ -#define DUK_HTHREAD_STATE_TERMINATED 5 /* thread has terminated */ - -/* Executor interrupt default interval when nothing else requires a - * smaller value. The default interval must be small enough to allow - * for reasonable execution timeout checking but large enough to keep - * impact on execution performance low. - */ -#if defined(DUK_USE_INTERRUPT_COUNTER) -#define DUK_HTHREAD_INTCTR_DEFAULT (256L * 1024L) -#endif - -/* - * Assert context is valid: non-NULL pointer, fields look sane. - * - * This is used by public API call entrypoints to catch invalid 'ctx' pointers - * as early as possible; invalid 'ctx' pointers cause very odd and difficult to - * diagnose behavior so it's worth checking even when the check is not 100%. - */ - -#if defined(DUK_USE_PREFER_SIZE) -#define DUK_ASSERT_CTX_VSSIZE(ctx) /*nop*/ -#else -#define DUK_ASSERT_CTX_VSSIZE(ctx) \ - DUK_ASSERT((duk_size_t) (((duk_hthread *) (ctx))->valstack_end - ((duk_hthread *) (ctx))->valstack) == \ - ((duk_hthread *) (ctx))->valstack_size) -#endif -#define DUK_ASSERT_CTX_VALID(ctx) do { \ - DUK_ASSERT((ctx) != NULL); \ - DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) (ctx)) == DUK_HTYPE_OBJECT); \ - DUK_ASSERT(DUK_HOBJECT_IS_THREAD((duk_hobject *) (ctx))); \ - DUK_ASSERT(((duk_hthread *) (ctx))->unused1 == 0); \ - DUK_ASSERT(((duk_hthread *) (ctx))->unused2 == 0); \ - DUK_ASSERT(((duk_hthread *) (ctx))->valstack != NULL); \ - DUK_ASSERT(((duk_hthread *) (ctx))->valstack_end >= ((duk_hthread *) (ctx))->valstack); \ - DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack); \ - DUK_ASSERT(((duk_hthread *) (ctx))->valstack_top >= ((duk_hthread *) (ctx))->valstack_bottom); \ - DUK_ASSERT(((duk_hthread *) (ctx))->valstack_end >= ((duk_hthread *) (ctx))->valstack_top); \ - DUK_ASSERT_CTX_VSSIZE((ctx)); \ - } while (0) - -/* - * Struct defines - */ - -/* XXX: for a memory-code tradeoff, remove 'func' and make it's access either a function - * or a macro. This would make the activation 32 bytes long on 32-bit platforms again. - */ - -/* Note: it's nice if size is 2^N (at least for 32-bit platforms). */ -struct duk_activation { - duk_tval tv_func; /* borrowed: full duk_tval for function being executed; for lightfuncs */ - duk_hobject *func; /* borrowed: function being executed; for bound function calls, this is the final, real function, NULL for lightfuncs */ - duk_hobject *var_env; /* current variable environment (may be NULL if delayed) */ - duk_hobject *lex_env; /* current lexical environment (may be NULL if delayed) */ -#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY - /* Previous value of 'func' caller, restored when unwound. Only in use - * when 'func' is non-strict. - */ - duk_hobject *prev_caller; -#endif - - duk_instr_t *curr_pc; /* next instruction to execute (points to 'func' bytecode, stable pointer), NULL for native calls */ -#if defined(DUK_USE_DEBUGGER_SUPPORT) - duk_uint32_t prev_line; /* needed for stepping */ -#endif - duk_small_uint_t flags; - - /* idx_bottom and idx_retval are only used for book-keeping of - * Ecmascript-initiated calls, to allow returning to an Ecmascript - * function properly. They are duk_size_t to match the convention - * that value stack sizes are duk_size_t and local frame indices - * are duk_idx_t. - */ - - /* Bottom of valstack for this activation, used to reset - * valstack_bottom on return; index is absolute. Note: - * idx_top not needed because top is set to 'nregs' always - * when returning to an Ecmascript activation. - */ - duk_size_t idx_bottom; - - /* Return value when returning to this activation (points to caller - * reg, not callee reg); index is absolute (only set if activation is - * not topmost). - * - * Note: idx_bottom is always set, while idx_retval is only applicable - * for activations below the topmost one. Currently idx_retval for - * the topmost activation is considered garbage (and it not initialized - * on entry or cleared on return; may contain previous or garbage - * values). - */ - duk_size_t idx_retval; - - /* Current 'this' binding is the value just below idx_bottom. - * Previously, 'this' binding was handled with an index to the - * (calling) valstack. This works for everything except tail - * calls, which must not "cumulate" valstack temps. - */ -}; - -/* Note: it's nice if size is 2^N (not 4x4 = 16 bytes on 32 bit) */ -struct duk_catcher { - duk_hstring *h_varname; /* borrowed reference to catch variable name (or NULL if none) */ - /* (reference is valid as long activation exists) */ - duk_instr_t *pc_base; /* resume execution from pc_base or pc_base+1 (points to 'func' bytecode, stable pointer) */ - duk_size_t callstack_index; /* callstack index of related activation */ - duk_size_t idx_base; /* idx_base and idx_base+1 get completion value and type */ - duk_uint32_t flags; /* type and control flags, label number */ -}; - -struct duk_hthread { - /* Shared object part */ - duk_hobject obj; - - /* Pointer to bytecode executor's 'curr_pc' variable. Used to copy - * the current PC back into the topmost activation when activation - * state is about to change (or "syncing" is otherwise needed). This - * is rather awkward but important for performance, see execution.rst. - */ - duk_instr_t **ptr_curr_pc; - - /* Backpointers. */ - duk_heap *heap; - - /* Current strictness flag: affects API calls. */ - duk_uint8_t strict; - - /* Thread state. */ - duk_uint8_t state; - duk_uint8_t unused1; - duk_uint8_t unused2; - - /* Sanity limits for stack sizes. */ - duk_size_t valstack_max; - duk_size_t callstack_max; - duk_size_t catchstack_max; - - /* XXX: Valstack, callstack, and catchstack are currently assumed - * to have non-NULL pointers. Relaxing this would not lead to big - * benefits (except perhaps for terminated threads). - */ - - /* Value stack: these are expressed as pointers for faster stack manipulation. - * [valstack,valstack_top[ is GC-reachable, [valstack_top,valstack_end[ is - * not GC-reachable but kept initialized as 'undefined'. - */ - duk_tval *valstack; /* start of valstack allocation */ - duk_tval *valstack_end; /* end of valstack allocation (exclusive) */ - duk_tval *valstack_bottom; /* bottom of current frame */ - duk_tval *valstack_top; /* top of current frame (exclusive) */ -#if !defined(DUK_USE_PREFER_SIZE) - duk_size_t valstack_size; /* cached: valstack_end - valstack (in entries, not bytes) */ -#endif - - /* Call stack. [0,callstack_top[ is GC reachable. */ - duk_activation *callstack; - duk_size_t callstack_size; /* allocation size */ - duk_size_t callstack_top; /* next to use, highest used is top - 1 */ - duk_size_t callstack_preventcount; /* number of activation records in callstack preventing a yield */ - - /* Catch stack. [0,catchstack_top[ is GC reachable. */ - duk_catcher *catchstack; - duk_size_t catchstack_size; /* allocation size */ - duk_size_t catchstack_top; /* next to use, highest used is top - 1 */ - - /* Yield/resume book-keeping. */ - duk_hthread *resumer; /* who resumed us (if any) */ - - /* Current compiler state (if any), used for augmenting SyntaxErrors. */ - duk_compiler_ctx *compile_ctx; - -#if defined(DUK_USE_INTERRUPT_COUNTER) - /* Interrupt counter for triggering a slow path check for execution - * timeout, debugger interaction such as breakpoints, etc. The value - * is valid for the current running thread, and both the init and - * counter values are copied whenever a thread switch occurs. It's - * important for the counter to be conveniently accessible for the - * bytecode executor inner loop for performance reasons. - */ - duk_int_t interrupt_counter; /* countdown state */ - duk_int_t interrupt_init; /* start value for current countdown */ -#endif - - /* Builtin-objects; may or may not be shared with other threads, - * threads existing in different "compartments" will have different - * built-ins. Must be stored on a per-thread basis because there - * is no intermediate structure for a thread group / compartment. - * This takes quite a lot of space, currently 43x4 = 172 bytes on - * 32-bit platforms. - * - * In some cases the builtins array could be ROM based, but it's - * sometimes edited (e.g. for sandboxing) so it's better to keep - * this array in RAM. - */ - duk_hobject *builtins[DUK_NUM_BUILTINS]; - - /* Convenience copies from heap/vm for faster access. */ -#if defined(DUK_USE_ROM_STRINGS) - /* No field needed when strings are in ROM. */ -#else -#if defined(DUK_USE_HEAPPTR16) - duk_uint16_t *strs16; -#else - duk_hstring **strs; -#endif -#endif -}; - -/* - * Prototypes - */ - -DUK_INTERNAL_DECL void duk_hthread_copy_builtin_objects(duk_hthread *thr_from, duk_hthread *thr_to); -DUK_INTERNAL_DECL void duk_hthread_create_builtin_objects(duk_hthread *thr); -DUK_INTERNAL_DECL duk_bool_t duk_hthread_init_stacks(duk_heap *heap, duk_hthread *thr); -DUK_INTERNAL_DECL void duk_hthread_terminate(duk_hthread *thr); - -DUK_INTERNAL_DECL void duk_hthread_callstack_grow(duk_hthread *thr); -DUK_INTERNAL_DECL void duk_hthread_callstack_shrink_check(duk_hthread *thr); -DUK_INTERNAL_DECL void duk_hthread_callstack_unwind(duk_hthread *thr, duk_size_t new_top); -DUK_INTERNAL_DECL void duk_hthread_catchstack_grow(duk_hthread *thr); -DUK_INTERNAL_DECL void duk_hthread_catchstack_shrink_check(duk_hthread *thr); -DUK_INTERNAL_DECL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new_top); - -DUK_INTERNAL_DECL duk_activation *duk_hthread_get_current_activation(duk_hthread *thr); -DUK_INTERNAL_DECL void *duk_hthread_get_valstack_ptr(duk_heap *heap, void *ud); /* indirect allocs */ -DUK_INTERNAL_DECL void *duk_hthread_get_callstack_ptr(duk_heap *heap, void *ud); /* indirect allocs */ -DUK_INTERNAL_DECL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud); /* indirect allocs */ - -#if defined(DUK_USE_DEBUGGER_SUPPORT) -DUK_INTERNAL_DECL duk_uint_fast32_t duk_hthread_get_act_curr_pc(duk_hthread *thr, duk_activation *act); -#endif -DUK_INTERNAL_DECL duk_uint_fast32_t duk_hthread_get_act_prev_pc(duk_hthread *thr, duk_activation *act); -DUK_INTERNAL_DECL void duk_hthread_sync_currpc(duk_hthread *thr); -DUK_INTERNAL_DECL void duk_hthread_sync_and_null_currpc(duk_hthread *thr); - -#endif /* DUK_HTHREAD_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_hthread_alloc.c ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_alloc.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_alloc.c deleted file mode 100644 index 32857ef..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_alloc.c +++ /dev/null @@ -1,95 +0,0 @@ -/* - * duk_hthread allocation and freeing. - */ - -#include "duk_internal.h" - -/* - * Allocate initial stacks for a thread. Note that 'thr' must be reachable - * as a garbage collection may be triggered by the allocation attempts. - * Returns zero (without leaking memory) if init fails. - */ - -DUK_INTERNAL duk_bool_t duk_hthread_init_stacks(duk_heap *heap, duk_hthread *thr) { - duk_size_t alloc_size; - duk_size_t i; - - DUK_ASSERT(heap != NULL); - DUK_ASSERT(thr != NULL); - DUK_ASSERT(thr->valstack == NULL); - DUK_ASSERT(thr->valstack_end == NULL); - DUK_ASSERT(thr->valstack_bottom == NULL); - DUK_ASSERT(thr->valstack_top == NULL); - DUK_ASSERT(thr->callstack == NULL); - DUK_ASSERT(thr->catchstack == NULL); - - /* valstack */ - alloc_size = sizeof(duk_tval) * DUK_VALSTACK_INITIAL_SIZE; - thr->valstack = (duk_tval *) DUK_ALLOC(heap, alloc_size); - if (!thr->valstack) { - goto fail; - } - DUK_MEMZERO(thr->valstack, alloc_size); - thr->valstack_end = thr->valstack + DUK_VALSTACK_INITIAL_SIZE; -#if !defined(DUK_USE_PREFER_SIZE) - thr->valstack_size = DUK_VALSTACK_INITIAL_SIZE; -#endif - thr->valstack_bottom = thr->valstack; - thr->valstack_top = thr->valstack; - - for (i = 0; i < DUK_VALSTACK_INITIAL_SIZE; i++) { - DUK_TVAL_SET_UNDEFINED(&thr->valstack[i]); - } - - /* callstack */ - alloc_size = sizeof(duk_activation) * DUK_CALLSTACK_INITIAL_SIZE; - thr->callstack = (duk_activation *) DUK_ALLOC(heap, alloc_size); - if (!thr->callstack) { - goto fail; - } - DUK_MEMZERO(thr->callstack, alloc_size); - thr->callstack_size = DUK_CALLSTACK_INITIAL_SIZE; - DUK_ASSERT(thr->callstack_top == 0); - - /* catchstack */ - alloc_size = sizeof(duk_catcher) * DUK_CATCHSTACK_INITIAL_SIZE; - thr->catchstack = (duk_catcher *) DUK_ALLOC(heap, alloc_size); - if (!thr->catchstack) { - goto fail; - } - DUK_MEMZERO(thr->catchstack, alloc_size); - thr->catchstack_size = DUK_CATCHSTACK_INITIAL_SIZE; - DUK_ASSERT(thr->catchstack_top == 0); - - return 1; - - fail: - DUK_FREE(heap, thr->valstack); - DUK_FREE(heap, thr->callstack); - DUK_FREE(heap, thr->catchstack); - - thr->valstack = NULL; - thr->callstack = NULL; - thr->catchstack = NULL; - return 0; -} - -/* For indirect allocs. */ - -DUK_INTERNAL void *duk_hthread_get_valstack_ptr(duk_heap *heap, void *ud) { - duk_hthread *thr = (duk_hthread *) ud; - DUK_UNREF(heap); - return (void *) thr->valstack; -} - -DUK_INTERNAL void *duk_hthread_get_callstack_ptr(duk_heap *heap, void *ud) { - duk_hthread *thr = (duk_hthread *) ud; - DUK_UNREF(heap); - return (void *) thr->callstack; -} - -DUK_INTERNAL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud) { - duk_hthread *thr = (duk_hthread *) ud; - DUK_UNREF(heap); - return (void *) thr->catchstack; -} 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_hthread_builtins.c ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_builtins.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_builtins.c deleted file mode 100644 index e8d57d8..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_builtins.c +++ /dev/null @@ -1,836 +0,0 @@ -/* - * Initialize built-in objects. Current thread must have a valstack - * and initialization errors may longjmp, so a setjmp() catch point - * must exist. - */ - -#include "duk_internal.h" - -/* - * Encoding constants, must match genbuiltins.py - */ - -#define DUK__CLASS_BITS 5 -#define DUK__BIDX_BITS 7 -#define DUK__STRIDX_BITS 9 /* XXX: try to optimize to 8 (would now be possible, <200 used) */ -#define DUK__NATIDX_BITS 8 -#define DUK__NUM_NORMAL_PROPS_BITS 6 -#define DUK__NUM_FUNC_PROPS_BITS 6 -#define DUK__PROP_FLAGS_BITS 3 -#define DUK__STRING_LENGTH_BITS 8 -#define DUK__STRING_CHAR_BITS 7 -#define DUK__LENGTH_PROP_BITS 3 -#define DUK__NARGS_BITS 3 -#define DUK__PROP_TYPE_BITS 3 -#define DUK__MAGIC_BITS 16 - -#define DUK__NARGS_VARARGS_MARKER 0x07 -#define DUK__NO_CLASS_MARKER 0x00 /* 0 = DUK_HOBJECT_CLASS_UNUSED */ -#define DUK__NO_BIDX_MARKER 0x7f -#define DUK__NO_STRIDX_MARKER 0xff - -#define DUK__PROP_TYPE_DOUBLE 0 -#define DUK__PROP_TYPE_STRING 1 -#define DUK__PROP_TYPE_STRIDX 2 -#define DUK__PROP_TYPE_BUILTIN 3 -#define DUK__PROP_TYPE_UNDEFINED 4 -#define DUK__PROP_TYPE_BOOLEAN_TRUE 5 -#define DUK__PROP_TYPE_BOOLEAN_FALSE 6 -#define DUK__PROP_TYPE_ACCESSOR 7 - -/* - * Create built-in objects by parsing an init bitstream generated - * by genbuiltins.py. - */ - -#if defined(DUK_USE_ROM_OBJECTS) -#if defined(DUK_USE_ROM_GLOBAL_CLONE) || defined(DUK_USE_ROM_GLOBAL_INHERIT) -DUK_LOCAL void duk__duplicate_ram_global_object(duk_hthread *thr) { - duk_context *ctx; - duk_hobject *h1; -#if defined(DUK_USE_ROM_GLOBAL_CLONE) - duk_hobject *h2; - duk_uint8_t *props; - duk_size_t alloc_size; -#endif - - ctx = (duk_context *) thr; - - /* XXX: refactor into internal helper, duk_clone_hobject() */ - -#if defined(DUK_USE_ROM_GLOBAL_INHERIT) - /* Inherit from ROM-based global object: less RAM usage, less transparent. */ - duk_push_object_helper(ctx, - DUK_HOBJECT_FLAG_EXTENSIBLE | - DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_GLOBAL), - DUK_BIDX_GLOBAL); - h1 = duk_get_hobject(ctx, -1); - DUK_ASSERT(h1 != NULL); -#elif defined(DUK_USE_ROM_GLOBAL_CLONE) - /* Clone the properties of the ROM-based global object to create a - * fully RAM-based global object. Uses more memory than the inherit - * model but more compliant. - */ - duk_push_object_helper(ctx, - DUK_HOBJECT_FLAG_EXTENSIBLE | - DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_GLOBAL), - DUK_BIDX_OBJECT_PROTOTYPE); - h1 = duk_get_hobject(ctx, -1); - DUK_ASSERT(h1 != NULL); - h2 = thr->builtins[DUK_BIDX_GLOBAL]; - DUK_ASSERT(h2 != NULL); - - /* Copy the property table verbatim; this handles attributes etc. - * For ROM objects it's not necessary (or possible) to update - * refcounts so leave them as is. - */ - alloc_size = DUK_HOBJECT_P_ALLOC_SIZE(h2); - DUK_ASSERT(alloc_size > 0); - props = DUK_ALLOC(thr->heap, alloc_size); - if (!props) { - DUK_ERROR_ALLOC_DEFMSG(thr); - return; - } - DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, h2) != NULL); - DUK_MEMCPY((void *) props, (const void *) DUK_HOBJECT_GET_PROPS(thr->heap, h2), alloc_size); - - /* XXX: keep property attributes or tweak them here? - * Properties will now be non-configurable even when they're - * normally configurable for the global object. - */ - - DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, h1) == NULL); - DUK_HOBJECT_SET_PROPS(thr->heap, h1, props); - DUK_HOBJECT_SET_ESIZE(h1, DUK_HOBJECT_GET_ESIZE(h2)); - DUK_HOBJECT_SET_ENEXT(h1, DUK_HOBJECT_GET_ENEXT(h2)); - DUK_HOBJECT_SET_ASIZE(h1, DUK_HOBJECT_GET_ASIZE(h2)); - DUK_HOBJECT_SET_HSIZE(h1, DUK_HOBJECT_GET_HSIZE(h2)); -#else -#error internal error in defines -#endif - - duk_hobject_compact_props(thr, h1); - DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL); - DUK_ASSERT(!DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE((duk_heaphdr *) thr->builtins[DUK_BIDX_GLOBAL])); /* no need to decref */ - thr->builtins[DUK_BIDX_GLOBAL] = h1; - DUK_HOBJECT_INCREF(thr, h1); - DUK_D(DUK_DPRINT("duplicated global object: %!O", h1)); - - - /* Create a fresh object environment for the global scope. This is - * needed so that the global scope points to the newly created RAM-based - * global object. - */ - duk_push_object_helper(ctx, - DUK_HOBJECT_FLAG_EXTENSIBLE | - DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJENV), - -1); /* no prototype */ - h1 = duk_get_hobject(ctx, -1); - DUK_ASSERT(h1 != NULL); - duk_dup(ctx, -2); - duk_dup(ctx, -1); /* -> [ ... new_global new_globalenv new_global new_global ] */ - duk_xdef_prop_stridx(thr, -3, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE); - duk_xdef_prop_stridx(thr, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE); /* always provideThis=true */ - - duk_hobject_compact_props(thr, h1); - DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL_ENV] != NULL); - DUK_ASSERT(!DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE((duk_heaphdr *) thr->builtins[DUK_BIDX_GLOBAL_ENV])); /* no need to decref */ - thr->builtins[DUK_BIDX_GLOBAL_ENV] = h1; - DUK_HOBJECT_INCREF(thr, h1); - DUK_D(DUK_DPRINT("duplicated global env: %!O", h1)); - - duk_pop_2(ctx); -} -#endif /* DUK_USE_ROM_GLOBAL_CLONE || DUK_USE_ROM_GLOBAL_INHERIT */ - -DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) { - /* Setup builtins from ROM objects. All heaps/threads will share - * the same readonly objects. - */ - duk_small_uint_t i; - - for (i = 0; i < DUK_NUM_BUILTINS; i++) { - duk_hobject *h; - h = (duk_hobject *) DUK_LOSE_CONST(duk_rom_builtins_bidx[i]); - DUK_ASSERT(h != NULL); - thr->builtins[i] = h; - } - -#if defined(DUK_USE_ROM_GLOBAL_CLONE) || defined(DUK_USE_ROM_GLOBAL_INHERIT) - /* By default the global object is read-only which is often much - * more of an issue than having read-only built-in objects (like - * RegExp, Date, etc). Use a RAM-based copy of the global object - * and the global environment object for convenience. - */ - duk__duplicate_ram_global_object(thr); -#endif -} -#else /* DUK_USE_ROM_OBJECTS */ -DUK_LOCAL void duk__push_stridx(duk_context *ctx, duk_bitdecoder_ctx *bd) { - duk_small_uint_t n; - - n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS); - DUK_ASSERT_DISABLE(n >= 0); /* unsigned */ - DUK_ASSERT(n < DUK_HEAP_NUM_STRINGS); - duk_push_hstring_stridx(ctx, n); -} -DUK_LOCAL void duk__push_string(duk_context *ctx, duk_bitdecoder_ctx *bd) { - duk_small_uint_t n; - duk_small_uint_t i; - duk_uint8_t *p; - - n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRING_LENGTH_BITS); - p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, n); - for (i = 0; i < n; i++) { - *p++ = (duk_uint8_t) duk_bd_decode(bd, DUK__STRING_CHAR_BITS); - } - duk_to_string(ctx, -1); -} -DUK_LOCAL void duk__push_stridx_or_string(duk_context *ctx, duk_bitdecoder_ctx *bd) { - if (duk_bd_decode_flag(bd)) { - duk__push_string(ctx, bd); - } else { - duk__push_stridx(ctx, bd); - } -} -DUK_LOCAL void duk__push_double(duk_context *ctx, duk_bitdecoder_ctx *bd) { - duk_double_union du; - duk_small_uint_t i; - - for (i = 0; i < 8; i++) { - /* Encoding endianness must match target memory layout, - * build scripts and genbuiltins.py must ensure this. - */ - du.uc[i] = (duk_uint8_t) duk_bd_decode(bd, 8); - } - - duk_push_number(ctx, du.d); /* push operation normalizes NaNs */ -} - -DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) { - duk_context *ctx = (duk_context *) thr; - duk_bitdecoder_ctx bd_ctx; - duk_bitdecoder_ctx *bd = &bd_ctx; /* convenience */ - duk_hobject *h; - duk_small_uint_t i, j; - - DUK_D(DUK_DPRINT("INITBUILTINS BEGIN: DUK_NUM_BUILTINS=%d, DUK_NUM_BUILTINS_ALL=%d", (int) DUK_NUM_BUILTINS, (int) DUK_NUM_ALL_BUILTINS)); - - DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx)); - bd->data = (const duk_uint8_t *) duk_builtins_data; - bd->length = (duk_size_t) DUK_BUILTINS_DATA_LENGTH; - - /* - * First create all built-in bare objects on the empty valstack. - * - * Built-ins in the index range [0,DUK_NUM_BUILTINS-1] have value - * stack indices matching their eventual thr->builtins[] index. - * - * Built-ins in the index range [DUK_NUM_BUILTINS,DUK_NUM_ALL_BUILTINS] - * will exist on the value stack during init but won't be placed - * into thr->builtins[]. These are objects referenced in some way - * from thr->builtins[] roots but which don't need to be indexed by - * Duktape through thr->builtins[] (e.g. user custom objects). - */ - - duk_require_stack(ctx, DUK_NUM_ALL_BUILTINS); - - DUK_DD(DUK_DDPRINT("create empty built-ins")); - DUK_ASSERT_TOP(ctx, 0); - for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) { - duk_small_uint_t class_num; - duk_small_int_t len = -1; /* must be signed */ - - class_num = (duk_small_uint_t) duk_bd_decode(bd, DUK__CLASS_BITS); - len = (duk_small_int_t) duk_bd_decode_flagged(bd, DUK__LENGTH_PROP_BITS, (duk_int32_t) -1 /*def_value*/); - - if (class_num == DUK_HOBJECT_CLASS_FUNCTION) { - duk_small_uint_t natidx; - duk_int_t c_nargs; /* must hold DUK_VARARGS */ - duk_c_function c_func; - duk_int16_t magic; - - DUK_DDD(DUK_DDDPRINT("len=%ld", (long) len)); - DUK_ASSERT(len >= 0); - - natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS); - c_func = duk_bi_native_functions[natidx]; - - c_nargs = (duk_small_uint_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, len /*def_value*/); - if (c_nargs == DUK__NARGS_VARARGS_MARKER) { - c_nargs = DUK_VARARGS; - } - - /* XXX: set magic directly here? (it could share the c_nargs arg) */ - duk_push_c_function_noexotic(ctx, c_func, c_nargs); - - h = duk_require_hobject(ctx, -1); - DUK_ASSERT(h != NULL); - - /* Currently all built-in native functions are strict. - * duk_push_c_function() now sets strict flag, so - * assert for it. - */ - DUK_ASSERT(DUK_HOBJECT_HAS_STRICT(h)); - - /* XXX: function properties */ - - /* Built-in 'name' is not writable by default. Function '.name' - * is writable to allow user code to set a '.name' on a native - * function. - */ - duk__push_stridx_or_string(ctx, bd); - duk_xdef_prop_stridx(ctx, - -2, - DUK_STRIDX_NAME, - (i == DUK_BIDX_FUNCTION_PROTOTYPE) ? - DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE); - - /* Almost all global level Function objects are constructable - * but not all: Function.prototype is a non-constructable, - * callable Function. - */ - if (duk_bd_decode_flag(bd)) { - DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(h)); - } else { - DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h); - } - - /* Cast converts magic to 16-bit signed value */ - magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0 /*def_value*/); - ((duk_hnativefunction *) h)->magic = magic; - } else { - /* XXX: ARRAY_PART for Array prototype? */ - - duk_push_object_helper(ctx, - DUK_HOBJECT_FLAG_EXTENSIBLE, - -1); /* no prototype or class yet */ - - h = duk_require_hobject(ctx, -1); - DUK_ASSERT(h != NULL); - } - - DUK_HOBJECT_SET_CLASS_NUMBER(h, class_num); - - if (i < DUK_NUM_BUILTINS) { - thr->builtins[i] = h; - DUK_HOBJECT_INCREF(thr, &h->hdr); - } - - if (len >= 0) { - /* - * For top-level objects, 'length' property has the following - * default attributes: non-writable, non-enumerable, non-configurable - * (E5 Section 15). - * - * However, 'length' property for Array.prototype has attributes - * expected of an Array instance which are different: writable, - * non-enumerable, non-configurable (E5 Section 15.4.5.2). - * - * This is currently determined implicitly based on class; there are - * no attribute flags in the init data. - */ - - duk_push_int(ctx, len); - duk_xdef_prop_stridx(ctx, - -2, - DUK_STRIDX_LENGTH, - (class_num == DUK_HOBJECT_CLASS_ARRAY ? /* only Array.prototype matches */ - DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE)); - } - - /* enable exotic behaviors last */ - - if (class_num == DUK_HOBJECT_CLASS_ARRAY) { - DUK_HOBJECT_SET_EXOTIC_ARRAY(h); - } - if (class_num == DUK_HOBJECT_CLASS_STRING) { - DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h); - } - - /* some assertions */ - - DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h)); - /* DUK_HOBJECT_FLAG_CONSTRUCTABLE varies */ - DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(h)); - DUK_ASSERT(!DUK_HOBJECT_HAS_COMPILEDFUNCTION(h)); - /* DUK_HOBJECT_FLAG_NATIVEFUNCTION varies */ - DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(h)); - DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(h)); /* currently, even for Array.prototype */ - /* DUK_HOBJECT_FLAG_STRICT varies */ - DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(h) || /* all native functions have NEWENV */ - DUK_HOBJECT_HAS_NEWENV(h)); - DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(h)); - DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(h)); - DUK_ASSERT(!DUK_HOBJECT_HAS_ENVRECCLOSED(h)); - /* DUK_HOBJECT_FLAG_EXOTIC_ARRAY varies */ - /* DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ varies */ - DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h)); - - DUK_DDD(DUK_DDDPRINT("created built-in %ld, class=%ld, length=%ld", (long) i, (long) class_num, (long) len)); - } - - /* - * Then decode the builtins init data (see genbuiltins.py) to - * init objects - */ - - DUK_DD(DUK_DDPRINT("initialize built-in object properties")); - for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) { - duk_small_uint_t t; - duk_small_uint_t num; - - DUK_DDD(DUK_DDDPRINT("initializing built-in object at index %ld", (long) i)); - h = duk_require_hobject(ctx, i); - DUK_ASSERT(h != NULL); - - t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS); - if (t != DUK__NO_BIDX_MARKER) { - DUK_DDD(DUK_DDDPRINT("set internal prototype: built-in %ld", (long) t)); - DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, duk_require_hobject(ctx, t)); - } - - t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS); - if (t != DUK__NO_BIDX_MARKER) { - /* 'prototype' property for all built-in objects (which have it) has attributes: - * [[Writable]] = false, - * [[Enumerable]] = false, - * [[Configurable]] = false - */ - DUK_DDD(DUK_DDDPRINT("set external prototype: built-in %ld", (long) t)); - duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_PROTOTYPE, t, DUK_PROPDESC_FLAGS_NONE); - } - - t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS); - if (t != DUK__NO_BIDX_MARKER) { - /* 'constructor' property for all built-in objects (which have it) has attributes: - * [[Writable]] = true, - * [[Enumerable]] = false, - * [[Configurable]] = true - */ - DUK_DDD(DUK_DDDPRINT("set external constructor: built-in %ld", (long) t)); - duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_CONSTRUCTOR, t, DUK_PROPDESC_FLAGS_WC); - } - - /* normal valued properties */ - num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_NORMAL_PROPS_BITS); - DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld normal valued properties", (long) i, (long) num)); - for (j = 0; j < num; j++) { - duk_small_uint_t prop_flags; - - duk__push_stridx_or_string(ctx, bd); - - /* - * Property attribute defaults are defined in E5 Section 15 (first - * few pages); there is a default for all properties and a special - * default for 'length' properties. Variation from the defaults is - * signaled using a single flag bit in the bitstream. - */ - - if (duk_bd_decode_flag(bd)) { - prop_flags = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_FLAGS_BITS); - } else { - prop_flags = DUK_PROPDESC_FLAGS_WC; - } - - t = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_TYPE_BITS); - - DUK_DDD(DUK_DDDPRINT("built-in %ld, normal-valued property %ld, key %!T, flags 0x%02lx, type %ld", - (long) i, (long) j, duk_get_tval(ctx, -1), (unsigned long) prop_flags, (long) t)); - - switch (t) { - case DUK__PROP_TYPE_DOUBLE: { - duk__push_double(ctx, bd); - break; - } - case DUK__PROP_TYPE_STRING: { - duk__push_string(ctx, bd); - break; - } - case DUK__PROP_TYPE_STRIDX: { - duk__push_stridx(ctx, bd); - break; - } - case DUK__PROP_TYPE_BUILTIN: { - duk_small_uint_t bidx; - - bidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS); - DUK_ASSERT(bidx != DUK__NO_BIDX_MARKER); - duk_dup(ctx, (duk_idx_t) bidx); - break; - } - case DUK__PROP_TYPE_UNDEFINED: { - duk_push_undefined(ctx); - break; - } - case DUK__PROP_TYPE_BOOLEAN_TRUE: { - duk_push_true(ctx); - break; - } - case DUK__PROP_TYPE_BOOLEAN_FALSE: { - duk_push_false(ctx); - break; - } - case DUK__PROP_TYPE_ACCESSOR: { - duk_small_uint_t natidx_getter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS); - duk_small_uint_t natidx_setter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS); - duk_c_function c_func_getter; - duk_c_function c_func_setter; - - /* XXX: this is a bit awkward because there is no exposed helper - * in the API style, only this internal helper. - */ - DUK_DDD(DUK_DDDPRINT("built-in accessor property: objidx=%ld, key=%!T, getteridx=%ld, setteridx=%ld, flags=0x%04lx", - (long) i, duk_get_tval(ctx, -1), (long) natidx_getter, (long) natidx_setter, (unsigned long) prop_flags)); - - c_func_getter = duk_bi_native_functions[natidx_getter]; - c_func_setter = duk_bi_native_functions[natidx_setter]; - duk_push_c_function_noconstruct_noexotic(ctx, c_func_getter, 0); /* always 0 args */ - duk_push_c_function_noconstruct_noexotic(ctx, c_func_setter, 1); /* always 1 arg */ - - /* XXX: magic for getter/setter? use duk_def_prop()? */ - - DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_WRITABLE) == 0); /* genbuiltins.py ensures */ - - prop_flags |= DUK_PROPDESC_FLAG_ACCESSOR; /* accessor flag not encoded explicitly */ - duk_hobject_define_accessor_internal(thr, - duk_require_hobject(ctx, i), - duk_get_hstring(ctx, -3), - duk_require_hobject(ctx, -2), - duk_require_hobject(ctx, -1), - prop_flags); - duk_pop_3(ctx); /* key, getter and setter, now reachable through object */ - goto skip_value; - } - default: { - /* exhaustive */ - DUK_UNREACHABLE(); - } - } - - DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0); - duk_xdef_prop(ctx, i, prop_flags); - - skip_value: - continue; /* avoid empty label at the end of a compound statement */ - } - - /* native function properties */ - num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_FUNC_PROPS_BITS); - DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld function valued properties", (long) i, (long) num)); - for (j = 0; j < num; j++) { - duk_hstring *h_key; - duk_small_uint_t natidx; - duk_int_t c_nargs; /* must hold DUK_VARARGS */ - duk_small_uint_t c_length; - duk_int16_t magic; - duk_c_function c_func; - duk_hnativefunction *h_func; -#if defined(DUK_USE_LIGHTFUNC_BUILTINS) - duk_small_int_t lightfunc_eligible; -#endif - - duk__push_stridx_or_string(ctx, bd); - h_key = duk_get_hstring(ctx, -1); - DUK_ASSERT(h_key != NULL); - DUK_UNREF(h_key); - natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS); - - c_length = (duk_small_uint_t) duk_bd_decode(bd, DUK__LENGTH_PROP_BITS); - c_nargs = (duk_int_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, (duk_int32_t) c_length /*def_value*/); - if (c_nargs == DUK__NARGS_VARARGS_MARKER) { - c_nargs = DUK_VARARGS; - } - - c_func = duk_bi_native_functions[natidx]; - - DUK_DDD(DUK_DDDPRINT("built-in %ld, function-valued property %ld, key %!O, natidx %ld, length %ld, nargs %ld", - (long) i, (long) j, (duk_heaphdr *) h_key, (long) natidx, (long) c_length, - (c_nargs == DUK_VARARGS ? (long) -1 : (long) c_nargs))); - - /* Cast converts magic to 16-bit signed value */ - magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0); - -#if defined(DUK_USE_LIGHTFUNC_BUILTINS) - lightfunc_eligible = - ((c_nargs >= DUK_LFUNC_NARGS_MIN && c_nargs <= DUK_LFUNC_NARGS_MAX) || (c_nargs == DUK_VARARGS)) && - (c_length <= DUK_LFUNC_LENGTH_MAX) && - (magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX); - - if (h_key == DUK_HTHREAD_STRING_EVAL(thr) || - h_key == DUK_HTHREAD_STRING_YIELD(thr) || - h_key == DUK_HTHREAD_STRING_RESUME(thr) || - h_key == DUK_HTHREAD_STRING_REQUIRE(thr)) { - /* These functions have trouble working as lightfuncs. - * Some of them have specific asserts and some may have - * additional properties (e.g. 'require.id' may be written). - */ - DUK_D(DUK_DPRINT("reject as lightfunc: key=%!O, i=%d, j=%d", (duk_heaphdr *) h_key, (int) i, (int) j)); - lightfunc_eligible = 0; - } - - if (lightfunc_eligible) { - duk_tval tv_lfunc; - duk_small_uint_t lf_nargs = (c_nargs == DUK_VARARGS ? DUK_LFUNC_NARGS_VARARGS : c_nargs); - duk_small_uint_t lf_flags = DUK_LFUNC_FLAGS_PACK(magic, c_length, lf_nargs); - DUK_TVAL_SET_LIGHTFUNC(&tv_lfunc, c_func, lf_flags); - duk_push_tval(ctx, &tv_lfunc); - DUK_D(DUK_DPRINT("built-in function eligible as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld -> %!iT", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic, duk_get_tval(ctx, -1))); - goto lightfunc_skip; - } - - DUK_D(DUK_DPRINT("built-in function NOT ELIGIBLE as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic)); -#endif /* DUK_USE_LIGHTFUNC_BUILTINS */ - - /* [ (builtin objects) name ] */ - - duk_push_c_function_noconstruct_noexotic(ctx, c_func, c_nargs); - h_func = duk_require_hnativefunction(ctx, -1); - DUK_UNREF(h_func); - - /* Currently all built-in native functions are strict. - * This doesn't matter for many functions, but e.g. - * String.prototype.charAt (and other string functions) - * rely on being strict so that their 'this' binding is - * not automatically coerced. - */ - DUK_HOBJECT_SET_STRICT((duk_hobject *) h_func); - - /* No built-in functions are constructable except the top - * level ones (Number, etc). - */ - DUK_ASSERT(!DUK_HOBJECT_HAS_CONSTRUCTABLE((duk_hobject *) h_func)); - - /* XXX: any way to avoid decoding magic bit; there are quite - * many function properties and relatively few with magic values. - */ - h_func->magic = magic; - - /* [ (builtin objects) name func ] */ - - duk_push_int(ctx, c_length); - duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE); - - duk_dup(ctx, -2); - duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE); - - /* XXX: other properties of function instances; 'arguments', 'caller'. */ - - DUK_DD(DUK_DDPRINT("built-in object %ld, function property %ld -> %!T", - (long) i, (long) j, (duk_tval *) duk_get_tval(ctx, -1))); - - /* [ (builtin objects) name func ] */ - - /* - * The default property attributes are correct for all - * function valued properties of built-in objects now. - */ - -#if defined(DUK_USE_LIGHTFUNC_BUILTINS) - lightfunc_skip: -#endif - - duk_xdef_prop(ctx, i, DUK_PROPDESC_FLAGS_WC); - - /* [ (builtin objects) ] */ - } - } - - /* - * Special post-tweaks, for cases not covered by the init data format. - * - * - Set Date.prototype.toGMTString to Date.prototype.toUTCString. - * toGMTString is required to have the same Function object as - * toUTCString in E5 Section B.2.6. Note that while Smjs respects - * this, V8 does not (the Function objects are distinct). - * - * - Make DoubleError non-extensible. - * - * - Add info about most important effective compile options to Duktape. - * - * - Possibly remove some properties (values or methods) which are not - * desirable with current feature options but are not currently - * conditional in init data. - */ - - duk_get_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_UTC_STRING); - duk_xdef_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_GMT_STRING, DUK_PROPDESC_FLAGS_WC); - - h = duk_require_hobject(ctx, DUK_BIDX_DOUBLE_ERROR); - DUK_ASSERT(h != NULL); - DUK_HOBJECT_CLEAR_EXTENSIBLE(h); - -#if !defined(DUK_USE_ES6_OBJECT_PROTO_PROPERTY) - DUK_DD(DUK_DDPRINT("delete Object.prototype.__proto__ built-in which is not enabled in features")); - (void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_PROTOTYPE], DUK_HTHREAD_STRING___PROTO__(thr), DUK_DELPROP_FLAG_THROW); -#endif - -#if !defined(DUK_USE_ES6_OBJECT_SETPROTOTYPEOF) - DUK_DD(DUK_DDPRINT("delete Object.setPrototypeOf built-in which is not enabled in features")); - (void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_CONSTRUCTOR], DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr), DUK_DELPROP_FLAG_THROW); -#endif - - /* XXX: relocate */ - duk_push_string(ctx, - /* Endianness indicator */ -#if defined(DUK_USE_INTEGER_LE) - "l" -#elif defined(DUK_USE_INTEGER_BE) - "b" -#elif defined(DUK_USE_INTEGER_ME) /* integer mixed endian not really used now */ - "m" -#else - "?" -#endif -#if defined(DUK_USE_DOUBLE_LE) - "l" -#elif defined(DUK_USE_DOUBLE_BE) - "b" -#elif defined(DUK_USE_DOUBLE_ME) - "m" -#else - "?" -#endif - " " - /* Packed or unpacked tval */ -#if defined(DUK_USE_PACKED_TVAL) - "p" -#else - "u" -#endif -#if defined(DUK_USE_FASTINT) - "f" -#endif - " " - /* Low memory options */ -#if defined(DUK_USE_STRTAB_CHAIN) - "c" /* chain */ -#elif defined(DUK_USE_STRTAB_PROBE) - "p" /* probe */ -#else - "?" -#endif -#if !defined(DUK_USE_HEAPPTR16) && !defined(DUK_DATAPTR16) && !defined(DUK_FUNCPTR16) - "n" -#endif -#if defined(DUK_USE_HEAPPTR16) - "h" -#endif -#if defined(DUK_USE_DATAPTR16) - "d" -#endif -#if defined(DUK_USE_FUNCPTR16) - "f" -#endif -#if defined(DUK_USE_REFCOUNT16) - "R" -#endif -#if defined(DUK_USE_STRHASH16) - "H" -#endif -#if defined(DUK_USE_STRLEN16) - "S" -#endif -#if defined(DUK_USE_BUFLEN16) - "B" -#endif -#if defined(DUK_USE_OBJSIZES16) - "O" -#endif -#if defined(DUK_USE_LIGHTFUNC_BUILTINS) - "L" -#endif -#if defined(DUK_USE_ROM_STRINGS) || defined(DUK_USE_ROM_OBJECTS) - /* XXX: This won't be shown in practice now - * because this code is not run when builtins - * are in ROM. - */ - "Z" -#endif - " " - /* Object property allocation layout */ -#if defined(DUK_USE_HOBJECT_LAYOUT_1) - "p1" -#elif defined(DUK_USE_HOBJECT_LAYOUT_2) - "p2" -#elif defined(DUK_USE_HOBJECT_LAYOUT_3) - "p3" -#else - "p?" -#endif - " " - /* Alignment guarantee */ -#if (DUK_USE_ALIGN_BY == 4) - "a4" -#elif (DUK_USE_ALIGN_BY == 8) - "a8" -#elif (DUK_USE_ALIGN_BY == 1) - "a1" -#else -#error invalid DUK_USE_ALIGN_BY -#endif - " " - /* Architecture, OS, and compiler strings */ - DUK_USE_ARCH_STRING - " " - DUK_USE_OS_STRING - " " - DUK_USE_COMPILER_STRING); - duk_xdef_prop_stridx(ctx, DUK_BIDX_DUKTAPE, DUK_STRIDX_ENV, DUK_PROPDESC_FLAGS_WC); - - /* - * InitJS code - Ecmascript code evaluated from a built-in source - * which provides e.g. backward compatibility. User can also provide - * JS code to be evaluated at startup. - */ - -#ifdef DUK_USE_BUILTIN_INITJS - /* XXX: compression */ - DUK_DD(DUK_DDPRINT("running built-in initjs")); - duk_eval_string(ctx, (const char *) duk_initjs_data); /* initjs data is NUL terminated */ - duk_pop(ctx); -#endif /* DUK_USE_BUILTIN_INITJS */ - -#ifdef DUK_USE_USER_INITJS - /* XXX: compression (as an option) */ - DUK_DD(DUK_DDPRINT("running user initjs")); - duk_eval_string_noresult(ctx, (const char *) DUK_USE_USER_INITJS); -#endif /* DUK_USE_USER_INITJS */ - - /* - * Since built-ins are not often extended, compact them. - */ - - DUK_DD(DUK_DDPRINT("compact built-ins")); - for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) { - duk_hobject_compact_props(thr, duk_require_hobject(ctx, i)); - } - - DUK_D(DUK_DPRINT("INITBUILTINS END")); - -#ifdef DUK_USE_DDPRINT - for (i = 0; i < DUK_NUM_ALL_BUILTINS; i++) { - DUK_DD(DUK_DDPRINT("built-in object %ld after initialization and compacting: %!@iO", - (long) i, (duk_heaphdr *) duk_require_hobject(ctx, i))); - } -#endif - - /* - * Pop built-ins from stack: they are now INCREF'd and - * reachable from the builtins[] array or indirectly - * through builtins[]. - */ - - duk_set_top(ctx, 0); - DUK_ASSERT_TOP(ctx, 0); -} -#endif /* DUK_USE_ROM_OBJECTS */ - -DUK_INTERNAL void duk_hthread_copy_builtin_objects(duk_hthread *thr_from, duk_hthread *thr_to) { - duk_small_uint_t i; - - for (i = 0; i < DUK_NUM_BUILTINS; i++) { - thr_to->builtins[i] = thr_from->builtins[i]; - DUK_HOBJECT_INCREF_ALLOWNULL(thr_to, thr_to->builtins[i]); /* side effect free */ - } -} 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_hthread_misc.c ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_misc.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_misc.c deleted file mode 100644 index 7536689..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_misc.c +++ /dev/null @@ -1,108 +0,0 @@ -/* - * Thread support. - */ - -#include "duk_internal.h" - -DUK_INTERNAL void duk_hthread_terminate(duk_hthread *thr) { - DUK_ASSERT(thr != NULL); - - /* Order of unwinding is important */ - - duk_hthread_catchstack_unwind(thr, 0); - - duk_hthread_callstack_unwind(thr, 0); /* side effects, possibly errors */ - - thr->valstack_bottom = thr->valstack; - duk_set_top((duk_context *) thr, 0); /* unwinds valstack, updating refcounts */ - - thr->state = DUK_HTHREAD_STATE_TERMINATED; - - /* Here we could remove references to built-ins, but it may not be - * worth the effort because built-ins are quite likely to be shared - * with another (unterminated) thread, and terminated threads are also - * usually garbage collected quite quickly. Also, doing DECREFs - * could trigger finalization, which would run on the current thread - * and have access to only some of the built-ins. Garbage collection - * deals with this correctly already. - */ - - /* XXX: Shrink the stacks to minimize memory usage? May not - * be worth the effort because terminated threads are usually - * garbage collected quite soon. - */ -} - -DUK_INTERNAL duk_activation *duk_hthread_get_current_activation(duk_hthread *thr) { - DUK_ASSERT(thr != NULL); - - if (thr->callstack_top > 0) { - return thr->callstack + thr->callstack_top - 1; - } else { - return NULL; - } -} - -#if defined(DUK_USE_DEBUGGER_SUPPORT) -DUK_INTERNAL duk_uint_fast32_t duk_hthread_get_act_curr_pc(duk_hthread *thr, duk_activation *act) { - duk_instr_t *bcode; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(act != NULL); - DUK_UNREF(thr); - - /* XXX: store 'bcode' pointer to activation for faster lookup? */ - if (act->func && DUK_HOBJECT_IS_COMPILEDFUNCTION(act->func)) { - bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func)); - return (duk_uint_fast32_t) (act->curr_pc - bcode); - } - return 0; -} -#endif /* DUK_USE_DEBUGGER_SUPPORT */ - -DUK_INTERNAL duk_uint_fast32_t duk_hthread_get_act_prev_pc(duk_hthread *thr, duk_activation *act) { - duk_instr_t *bcode; - duk_uint_fast32_t ret; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT(act != NULL); - DUK_UNREF(thr); - - if (act->func && DUK_HOBJECT_IS_COMPILEDFUNCTION(act->func)) { - bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, (duk_hcompiledfunction *) (act->func)); - ret = (duk_uint_fast32_t) (act->curr_pc - bcode); - if (ret > 0) { - ret--; - } - return ret; - } - return 0; -} - -/* Write bytecode executor's curr_pc back to topmost activation (if any). */ -DUK_INTERNAL void duk_hthread_sync_currpc(duk_hthread *thr) { - duk_activation *act; - - DUK_ASSERT(thr != NULL); - - if (thr->ptr_curr_pc != NULL) { - /* ptr_curr_pc != NULL only when bytecode executor is active. */ - DUK_ASSERT(thr->callstack_top > 0); - act = thr->callstack + thr->callstack_top - 1; - act->curr_pc = *thr->ptr_curr_pc; - } -} - -DUK_INTERNAL void duk_hthread_sync_and_null_currpc(duk_hthread *thr) { - duk_activation *act; - - DUK_ASSERT(thr != NULL); - - if (thr->ptr_curr_pc != NULL) { - /* ptr_curr_pc != NULL only when bytecode executor is active. */ - DUK_ASSERT(thr->callstack_top > 0); - act = thr->callstack + thr->callstack_top - 1; - act->curr_pc = *thr->ptr_curr_pc; - thr->ptr_curr_pc = NULL; - } -} 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_hthread_stacks.c ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_stacks.c b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_stacks.c deleted file mode 100644 index 59b072d..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_hthread_stacks.c +++ /dev/null @@ -1,476 +0,0 @@ -/* - * Manipulation of thread stacks (valstack, callstack, catchstack). - * - * Ideally unwinding of stacks should have no side effects, which would - * then favor separate unwinding and shrink check primitives for each - * stack type. A shrink check may realloc and thus have side effects. - * - * However, currently callstack unwinding itself has side effects, as it - * needs to DECREF multiple objects, close environment records, etc. - * Stacks must thus be unwound in the correct order by the caller. - * - * (XXX: This should be probably reworked so that there is a shared - * unwind primitive which handles all stacks as requested, and knows - * the proper order for unwinding.) - * - * Valstack entries above 'top' are always kept initialized to - * "undefined unused". Callstack and catchstack entries above 'top' - * are not zeroed and are left as garbage. - * - * Value stack handling is mostly a part of the API implementation. - */ - -#include "duk_internal.h" - -/* check that there is space for at least one new entry */ -DUK_INTERNAL void duk_hthread_callstack_grow(duk_hthread *thr) { - duk_activation *new_ptr; - duk_size_t old_size; - duk_size_t new_size; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT_DISABLE(thr->callstack_top >= 0); /* avoid warning (unsigned) */ - DUK_ASSERT(thr->callstack_size >= thr->callstack_top); - - if (thr->callstack_top < thr->callstack_size) { - return; - } - - old_size = thr->callstack_size; - new_size = old_size + DUK_CALLSTACK_GROW_STEP; - - /* this is a bit approximate (errors out before max is reached); this is OK */ - if (new_size >= thr->callstack_max) { - DUK_ERROR_RANGE(thr, DUK_STR_CALLSTACK_LIMIT); - } - - DUK_DD(DUK_DDPRINT("growing callstack %ld -> %ld", (long) old_size, (long) new_size)); - - /* - * Note: must use indirect variant of DUK_REALLOC() because underlying - * pointer may be changed by mark-and-sweep. - */ - - DUK_ASSERT(new_size > 0); - new_ptr = (duk_activation *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_callstack_ptr, (void *) thr, sizeof(duk_activation) * new_size); - if (!new_ptr) { - /* No need for a NULL/zero-size check because new_size > 0) */ - DUK_ERROR_ALLOC_DEFMSG(thr); - } - thr->callstack = new_ptr; - thr->callstack_size = new_size; - - /* note: any entries above the callstack top are garbage and not zeroed */ -} - -DUK_INTERNAL void duk_hthread_callstack_shrink_check(duk_hthread *thr) { - duk_size_t new_size; - duk_activation *p; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT_DISABLE(thr->callstack_top >= 0); /* avoid warning (unsigned) */ - DUK_ASSERT(thr->callstack_size >= thr->callstack_top); - - if (thr->callstack_size - thr->callstack_top < DUK_CALLSTACK_SHRINK_THRESHOLD) { - return; - } - - new_size = thr->callstack_top + DUK_CALLSTACK_SHRINK_SPARE; - DUK_ASSERT(new_size >= thr->callstack_top); - - DUK_DD(DUK_DDPRINT("shrinking callstack %ld -> %ld", (long) thr->callstack_size, (long) new_size)); - - /* - * Note: must use indirect variant of DUK_REALLOC() because underlying - * pointer may be changed by mark-and-sweep. - */ - - /* shrink failure is not fatal */ - p = (duk_activation *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_callstack_ptr, (void *) thr, sizeof(duk_activation) * new_size); - if (p) { - thr->callstack = p; - thr->callstack_size = new_size; - } else { - /* Because new_size != 0, if condition doesn't need to be - * (p != NULL || new_size == 0). - */ - DUK_ASSERT(new_size != 0); - DUK_D(DUK_DPRINT("callstack shrink failed, ignoring")); - } - - /* note: any entries above the callstack top are garbage and not zeroed */ -} - -DUK_INTERNAL void duk_hthread_callstack_unwind(duk_hthread *thr, duk_size_t new_top) { - duk_size_t idx; - - DUK_DDD(DUK_DDDPRINT("unwind callstack top of thread %p from %ld to %ld", - (void *) thr, - (thr != NULL ? (long) thr->callstack_top : (long) -1), - (long) new_top)); - - DUK_ASSERT(thr); - DUK_ASSERT(thr->heap); - DUK_ASSERT_DISABLE(new_top >= 0); /* unsigned */ - DUK_ASSERT((duk_size_t) new_top <= thr->callstack_top); /* cannot grow */ - - /* - * The loop below must avoid issues with potential callstack - * reallocations. A resize (and other side effects) may happen - * e.g. due to finalizer/errhandler calls caused by a refzero or - * mark-and-sweep. Arbitrary finalizers may run, because when - * an environment record is refzero'd, it may refer to arbitrary - * values which also become refzero'd. - * - * So, the pointer 'p' is re-looked-up below whenever a side effect - * might have changed it. - */ - - idx = thr->callstack_top; - while (idx > new_top) { - duk_activation *act; - duk_hobject *func; -#ifdef DUK_USE_REFERENCE_COUNTING - duk_hobject *tmp; -#endif -#ifdef DUK_USE_DEBUGGER_SUPPORT - duk_heap *heap; -#endif - - idx--; - DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */ - DUK_ASSERT((duk_size_t) idx < thr->callstack_size); /* true, despite side effect resizes */ - - act = thr->callstack + idx; - /* With lightfuncs, act 'func' may be NULL */ - -#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY - /* - * Restore 'caller' property for non-strict callee functions. - */ - - func = DUK_ACT_GET_FUNC(act); - if (func != NULL && !DUK_HOBJECT_HAS_STRICT(func)) { - duk_tval *tv_caller; - duk_tval tv_tmp; - duk_hobject *h_tmp; - - tv_caller = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_CALLER(thr)); - - /* The act->prev_caller should only be set if the entry for 'caller' - * exists (as it is only set in that case, and the property is not - * configurable), but handle all the cases anyway. - */ - - if (tv_caller) { - DUK_TVAL_SET_TVAL(&tv_tmp, tv_caller); - if (act->prev_caller) { - /* Just transfer the refcount from act->prev_caller to tv_caller, - * so no need for a refcount update. This is the expected case. - */ - DUK_TVAL_SET_OBJECT(tv_caller, act->prev_caller); - act->prev_caller = NULL; - } else { - DUK_TVAL_SET_NULL(tv_caller); /* no incref needed */ - DUK_ASSERT(act->prev_caller == NULL); - } - DUK_TVAL_DECREF(thr, &tv_tmp); /* side effects */ - } else { - h_tmp = act->prev_caller; - if (h_tmp) { - act->prev_caller = NULL; - DUK_HOBJECT_DECREF(thr, h_tmp); /* side effects */ - } - } - act = thr->callstack + idx; /* avoid side effects */ - DUK_ASSERT(act->prev_caller == NULL); - } -#endif - - /* - * Unwind debugger state. If we unwind while stepping - * (either step over or step into), pause execution. - */ - -#if defined(DUK_USE_DEBUGGER_SUPPORT) - heap = thr->heap; - if (heap->dbg_step_thread == thr && - heap->dbg_step_csindex == idx) { - /* Pause for all step types: step into, step over, step out. - * This is the only place explicitly handling a step out. - */ - DUK_HEAP_SET_PAUSED(heap); - DUK_ASSERT(heap->dbg_step_thread == NULL); - } -#endif - - /* - * Close environment record(s) if they exist. - * - * Only variable environments are closed. If lex_env != var_env, it - * cannot currently contain any register bound declarations. - * - * Only environments created for a NEWENV function are closed. If an - * environment is created for e.g. an eval call, it must not be closed. - */ - - func = DUK_ACT_GET_FUNC(act); - if (func != NULL && !DUK_HOBJECT_HAS_NEWENV(func)) { - DUK_DDD(DUK_DDDPRINT("skip closing environments, envs not owned by this activation")); - goto skip_env_close; - } - /* func is NULL for lightfunc */ - - DUK_ASSERT(act->lex_env == act->var_env); - if (act->var_env != NULL) { - DUK_DDD(DUK_DDDPRINT("closing var_env record %p -> %!O", - (void *) act->var_env, (duk_heaphdr *) act->var_env)); - duk_js_close_environment_record(thr, act->var_env, func, act->idx_bottom); - act = thr->callstack + idx; /* avoid side effect issues */ - } - -#if 0 - if (act->lex_env != NULL) { - if (act->lex_env == act->var_env) { - /* common case, already closed, so skip */ - DUK_DD(DUK_DDPRINT("lex_env and var_env are the same and lex_env " - "already closed -> skip closing lex_env")); - ; - } else { - DUK_DD(DUK_DDPRINT("closing lex_env record %p -> %!O", - (void *) act->lex_env, (duk_heaphdr *) act->lex_env)); - duk_js_close_environment_record(thr, act->lex_env, DUK_ACT_GET_FUNC(act), act->idx_bottom); - act = thr->callstack + idx; /* avoid side effect issues */ - } - } -#endif - - DUK_ASSERT((act->lex_env == NULL) || - ((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) && - (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) && - (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) && - (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL))); - - DUK_ASSERT((act->var_env == NULL) || - ((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) && - (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) && - (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) && - (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL))); - - skip_env_close: - - /* - * Update preventcount - */ - - if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) { - DUK_ASSERT(thr->callstack_preventcount >= 1); - thr->callstack_preventcount--; - } - - /* - * Reference count updates - * - * Note: careful manipulation of refcounts. The top is - * not updated yet, so all the activations are reachable - * for mark-and-sweep (which may be triggered by decref). - * However, the pointers are NULL so this is not an issue. - */ - -#ifdef DUK_USE_REFERENCE_COUNTING - tmp = act->var_env; -#endif - act->var_env = NULL; -#ifdef DUK_USE_REFERENCE_COUNTING - DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); - act = thr->callstack + idx; /* avoid side effect issues */ -#endif - -#ifdef DUK_USE_REFERENCE_COUNTING - tmp = act->lex_env; -#endif - act->lex_env = NULL; -#ifdef DUK_USE_REFERENCE_COUNTING - DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); - act = thr->callstack + idx; /* avoid side effect issues */ -#endif - - /* Note: this may cause a corner case situation where a finalizer - * may see a currently reachable activation whose 'func' is NULL. - */ -#ifdef DUK_USE_REFERENCE_COUNTING - tmp = DUK_ACT_GET_FUNC(act); -#endif - act->func = NULL; -#ifdef DUK_USE_REFERENCE_COUNTING - DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp); - act = thr->callstack + idx; /* avoid side effect issues */ - DUK_UNREF(act); -#endif - } - - thr->callstack_top = new_top; - - /* - * We could clear the book-keeping variables for the topmost activation, - * but don't do so now. - */ -#if 0 - if (thr->callstack_top > 0) { - duk_activation *act = thr->callstack + thr->callstack_top - 1; - act->idx_retval = 0; - } -#endif - - /* Note: any entries above the callstack top are garbage and not zeroed. - * Also topmost activation idx_retval is garbage (not zeroed), and must - * be ignored. - */ -} - -DUK_INTERNAL void duk_hthread_catchstack_grow(duk_hthread *thr) { - duk_catcher *new_ptr; - duk_size_t old_size; - duk_size_t new_size; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT_DISABLE(thr->catchstack_top); /* avoid warning (unsigned) */ - DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top); - - if (thr->catchstack_top < thr->catchstack_size) { - return; - } - - old_size = thr->catchstack_size; - new_size = old_size + DUK_CATCHSTACK_GROW_STEP; - - /* this is a bit approximate (errors out before max is reached); this is OK */ - if (new_size >= thr->catchstack_max) { - DUK_ERROR_RANGE(thr, DUK_STR_CATCHSTACK_LIMIT); - } - - DUK_DD(DUK_DDPRINT("growing catchstack %ld -> %ld", (long) old_size, (long) new_size)); - - /* - * Note: must use indirect variant of DUK_REALLOC() because underlying - * pointer may be changed by mark-and-sweep. - */ - - DUK_ASSERT(new_size > 0); - new_ptr = (duk_catcher *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_catchstack_ptr, (void *) thr, sizeof(duk_catcher) * new_size); - if (!new_ptr) { - /* No need for a NULL/zero-size check because new_size > 0) */ - DUK_ERROR_ALLOC_DEFMSG(thr); - } - thr->catchstack = new_ptr; - thr->catchstack_size = new_size; - - /* note: any entries above the catchstack top are garbage and not zeroed */ -} - -DUK_INTERNAL void duk_hthread_catchstack_shrink_check(duk_hthread *thr) { - duk_size_t new_size; - duk_catcher *p; - - DUK_ASSERT(thr != NULL); - DUK_ASSERT_DISABLE(thr->catchstack_top >= 0); /* avoid warning (unsigned) */ - DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top); - - if (thr->catchstack_size - thr->catchstack_top < DUK_CATCHSTACK_SHRINK_THRESHOLD) { - return; - } - - new_size = thr->catchstack_top + DUK_CATCHSTACK_SHRINK_SPARE; - DUK_ASSERT(new_size >= thr->catchstack_top); - - DUK_DD(DUK_DDPRINT("shrinking catchstack %ld -> %ld", (long) thr->catchstack_size, (long) new_size)); - - /* - * Note: must use indirect variant of DUK_REALLOC() because underlying - * pointer may be changed by mark-and-sweep. - */ - - /* shrink failure is not fatal */ - p = (duk_catcher *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_catchstack_ptr, (void *) thr, sizeof(duk_catcher) * new_size); - if (p) { - thr->catchstack = p; - thr->catchstack_size = new_size; - } else { - /* Because new_size != 0, if condition doesn't need to be - * (p != NULL || new_size == 0). - */ - DUK_ASSERT(new_size != 0); - DUK_D(DUK_DPRINT("catchstack shrink failed, ignoring")); - } - - /* note: any entries above the catchstack top are garbage and not zeroed */ -} - -DUK_INTERNAL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new_top) { - duk_size_t idx; - - DUK_DDD(DUK_DDDPRINT("unwind catchstack top of thread %p from %ld to %ld", - (void *) thr, - (thr != NULL ? (long) thr->catchstack_top : (long) -1), - (long) new_top)); - - DUK_ASSERT(thr); - DUK_ASSERT(thr->heap); - DUK_ASSERT_DISABLE(new_top >= 0); /* unsigned */ - DUK_ASSERT((duk_size_t) new_top <= thr->catchstack_top); /* cannot grow */ - - /* - * Since there are no references in the catcher structure, - * unwinding is quite simple. The only thing we need to - * look out for is popping a possible lexical environment - * established for an active catch clause. - */ - - idx = thr->catchstack_top; - while (idx > new_top) { - duk_catcher *p; - duk_activation *act; - duk_hobject *env; - - idx--; - DUK_ASSERT_DISABLE(idx >= 0); /* unsigned */ - DUK_ASSERT((duk_size_t) idx < thr->catchstack_size); - - p = thr->catchstack + idx; - - if (DUK_CAT_HAS_LEXENV_ACTIVE(p)) { - DUK_DDD(DUK_DDDPRINT("unwinding catchstack idx %ld, callstack idx %ld, callstack top %ld: lexical environment active", - (long) idx, (long) p->callstack_index, (long) thr->callstack_top)); - - /* XXX: Here we have a nasty dependency: the need to manipulate - * the callstack means that catchstack must always be unwound by - * the caller before unwinding the callstack. This should be fixed - * later. - */ - - /* Note that multiple catchstack entries may refer to the same - * callstack entry. - */ - act = thr->callstack + p->callstack_index; - DUK_ASSERT(act >= thr->callstack); - DUK_ASSERT(act < thr->callstack + thr->callstack_top); - - DUK_DDD(DUK_DDDPRINT("catchstack_index=%ld, callstack_index=%ld, lex_env=%!iO", - (long) idx, (long) p->callstack_index, - (duk_heaphdr *) act->lex_env)); - - env = act->lex_env; /* current lex_env of the activation (created for catcher) */ - DUK_ASSERT(env != NULL); /* must be, since env was created when catcher was created */ - act->lex_env = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, env); /* prototype is lex_env before catcher created */ - DUK_HOBJECT_DECREF(thr, env); - - /* There is no need to decref anything else than 'env': if 'env' - * becomes unreachable, refzero will handle decref'ing its prototype. - */ - } - } - - thr->catchstack_top = new_top; - - /* note: any entries above the catchstack top are garbage and not zeroed */ -} 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_initjs_min.js ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_initjs_min.js b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_initjs_min.js deleted file mode 100644 index d3a9143..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_initjs_min.js +++ /dev/null @@ -1 +0,0 @@ -(function(d,a){function b(a,b,c){Object.defineProperty(a,b,{value:c,writable:!0,enumerable:!1,configurable:!0})}b(a.Logger,"clog",new a.Logger("C"));b(a,"modLoaded",Object.create(null))})(this,Duktape); 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_internal.h ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_internal.h b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_internal.h deleted file mode 100644 index 7c8c7af..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_internal.h +++ /dev/null @@ -1,79 +0,0 @@ -/* - * Top-level include file to be used for all (internal) source files. - * - * Source files should not include individual header files, as they - * have not been designed to be individually included. - */ - -#ifndef DUK_INTERNAL_H_INCLUDED -#define DUK_INTERNAL_H_INCLUDED - -/* - * The 'duktape.h' header provides the public API, but also handles all - * compiler and platform specific feature detection, Duktape feature - * resolution, inclusion of system headers, etc. These have been merged - * because the public API is also dependent on e.g. detecting appropriate - * C types which is quite platform/compiler specific especially for a non-C99 - * build. The public API is also dependent on the resolved feature set. - * - * Some actions taken by the merged header (such as including system headers) - * are not appropriate for building a user application. The define - * DUK_COMPILING_DUKTAPE allows the merged header to skip/include some - * sections depending on what is being built. - */ - -#define DUK_COMPILING_DUKTAPE -#include "duktape.h" - -/* - * User declarations, e.g. prototypes for user functions used by Duktape - * macros. Concretely, if DUK_USE_PANIC_HANDLER is used and the macro - * value calls a user function, it needs to be declared for Duktape - * compilation to avoid warnings. - */ - -DUK_USE_USER_DECLARE() - -/* - * Duktape includes (other than duk_features.h) - * - * The header files expect to be included in an order which satisfies header - * dependencies correctly (the headers themselves don't include any other - * includes). Forward declarations are used to break circular struct/typedef - * dependencies. - */ - -#include "duk_replacements.h" -#include "duk_jmpbuf.h" -#include "duk_exception.h" -#include "duk_forwdecl.h" -#include "duk_tval.h" /* builtins need e.g. duk_tval tag definitions */ -#include "duk_builtins.h" /* autogenerated: strings and built-in object init data */ - -#include "duk_util.h" -#include "duk_strings.h" -#include "duk_js_bytecode.h" -#include "duk_lexer.h" -#include "duk_js_compiler.h" -#include "duk_regexp.h" -#include "duk_heaphdr.h" -#include "duk_api_internal.h" -#include "duk_hstring.h" -#include "duk_hobject.h" -#include "duk_hcompiledfunction.h" -#include "duk_hnativefunction.h" -#include "duk_hbufferobject.h" -#include "duk_hthread.h" -#include "duk_hbuffer.h" -#include "duk_heap.h" -#include "duk_debugger.h" -#include "duk_debug.h" -#include "duk_error.h" -#include "duk_unicode.h" -#include "duk_json.h" -#include "duk_js.h" -#include "duk_numconv.h" -#include "duk_bi_protos.h" -#include "duk_selftest.h" - -#endif /* DUK_INTERNAL_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_jmpbuf.h ---------------------------------------------------------------------- diff --git a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_jmpbuf.h b/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_jmpbuf.h deleted file mode 100644 index c8774c5..0000000 --- a/thirdparty/civetweb-1.10/src/third_party/duktape-1.5.2/src-separate/duk_jmpbuf.h +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Wrapper for jmp_buf. - * - * This is used because jmp_buf is an array type for backward compatibility. - * Wrapping jmp_buf in a struct makes pointer references, sizeof, etc, - * behave more intuitively. - * - * http://en.wikipedia.org/wiki/Setjmp.h#Member_types - */ - -#ifndef DUK_JMPBUF_H_INCLUDED -#define DUK_JMPBUF_H_INCLUDED - -#if defined(DUK_USE_CPP_EXCEPTIONS) -struct duk_jmpbuf { - duk_small_int_t dummy; /* unused */ -}; -#else -struct duk_jmpbuf { - DUK_JMPBUF_TYPE jb; -}; -#endif - -#endif /* DUK_JMPBUF_H_INCLUDED */
