├── .github └── workflows │ └── CI.yml ├── .gitignore ├── CMakeLists.txt ├── README.md ├── deps ├── duktape │ ├── AUTHORS.rst │ ├── CMakeLists.txt │ ├── LICENSE.txt │ ├── Makefile.cmdline │ ├── Makefile.codepage │ ├── Makefile.coffee │ ├── Makefile.dukdebug │ ├── Makefile.eval │ ├── Makefile.eventloop │ ├── Makefile.hello │ ├── Makefile.jsoncbor │ ├── Makefile.jxpretty │ ├── Makefile.sandbox │ ├── Makefile.sharedlibrary │ ├── README.rst │ ├── config │ │ ├── README.rst │ │ ├── architectures.yaml │ │ ├── architectures │ │ │ ├── architecture_arm32.h.in │ │ │ ├── architecture_arm64.h.in │ │ │ ├── architecture_emscripten.h.in │ │ │ ├── architecture_generic.h.in │ │ │ ├── architecture_m68k.h.in │ │ │ ├── architecture_mips32.h.in │ │ │ ├── architecture_mips64.h.in │ │ │ ├── architecture_powerpc32.h.in │ │ │ ├── architecture_powerpc64.h.in │ │ │ ├── architecture_riscv32.h.in │ │ │ ├── architecture_riscv64.h.in │ │ │ ├── architecture_sparc32.h.in │ │ │ ├── architecture_sparc64.h.in │ │ │ ├── architecture_superh.h.in │ │ │ ├── architecture_x32.h.in │ │ │ ├── architecture_x64.h.in │ │ │ └── architecture_x86.h.in │ │ ├── compilers.yaml │ │ ├── compilers │ │ │ ├── compiler_bcc.h.in │ │ │ ├── compiler_clang.h.in │ │ │ ├── compiler_emscripten.h.in │ │ │ ├── compiler_gcc.h.in │ │ │ ├── compiler_generic.h.in │ │ │ ├── compiler_msvc.h.in │ │ │ ├── compiler_tinyc.h.in │ │ │ └── compiler_vbcc.h.in │ │ ├── config-options │ │ │ ├── DUK_USE_32BIT_PTRS.yaml │ │ │ ├── DUK_USE_64BIT_OPS.yaml │ │ │ ├── DUK_USE_ALIGN_4.yaml │ │ │ ├── DUK_USE_ALIGN_8.yaml │ │ │ ├── DUK_USE_ALIGN_BY.yaml │ │ │ ├── DUK_USE_ALLOW_UNDEFINED_BEHAVIOR.yaml │ │ │ ├── DUK_USE_ARCH_STRING.yaml │ │ │ ├── DUK_USE_ARRAY_BUILTIN.yaml │ │ │ ├── DUK_USE_ARRAY_FASTPATH.yaml │ │ │ ├── DUK_USE_ARRAY_PROP_FASTPATH.yaml │ │ │ ├── DUK_USE_ASSERTIONS.yaml │ │ │ ├── DUK_USE_ATAN2_WORKAROUNDS.yaml │ │ │ ├── DUK_USE_AUGMENT_ERROR_CREATE.yaml │ │ │ ├── DUK_USE_AUGMENT_ERROR_THROW.yaml │ │ │ ├── DUK_USE_AVOID_PLATFORM_FUNCPTRS.yaml │ │ │ ├── DUK_USE_BASE64_FASTPATH.yaml │ │ │ ├── DUK_USE_BASE64_SUPPORT.yaml │ │ │ ├── DUK_USE_BOOLEAN_BUILTIN.yaml │ │ │ ├── DUK_USE_BRANCH_HINTS.yaml │ │ │ ├── DUK_USE_BROWSER_LIKE.yaml │ │ │ ├── DUK_USE_BUFFEROBJECT_SUPPORT.yaml │ │ │ ├── DUK_USE_BUFLEN16.yaml │ │ │ ├── DUK_USE_BUILTIN_INITJS.yaml │ │ │ ├── DUK_USE_BYTECODE_DUMP_SUPPORT.yaml │ │ │ ├── DUK_USE_BYTEORDER.yaml │ │ │ ├── DUK_USE_BYTEORDER_FORCED.yaml │ │ │ ├── DUK_USE_CACHE_ACTIVATION.yaml │ │ │ ├── DUK_USE_CACHE_CATCHER.yaml │ │ │ ├── DUK_USE_CALLSTACK_LIMIT.yaml │ │ │ ├── DUK_USE_CBOR_BUILTIN.yaml │ │ │ ├── DUK_USE_CBOR_DEC_RECLIMIT.yaml │ │ │ ├── DUK_USE_CBOR_ENC_RECLIMIT.yaml │ │ │ ├── DUK_USE_CBOR_SUPPORT.yaml │ │ │ ├── DUK_USE_CLANG_PRAGMAS.yaml │ │ │ ├── DUK_USE_COMMONJS_MODULES.yaml │ │ │ ├── DUK_USE_COMPILER_RECLIMIT.yaml │ │ │ ├── DUK_USE_COMPILER_STRING.yaml │ │ │ ├── DUK_USE_COMPUTED_INFINITY.yaml │ │ │ ├── DUK_USE_COMPUTED_NAN.yaml │ │ │ ├── DUK_USE_COROUTINE_SUPPORT.yaml │ │ │ ├── DUK_USE_CPP_EXCEPTIONS.yaml │ │ │ ├── DUK_USE_DATAPTR16.yaml │ │ │ ├── DUK_USE_DATAPTR_DEC16.yaml │ │ │ ├── DUK_USE_DATAPTR_ENC16.yaml │ │ │ ├── DUK_USE_DATE_BUILTIN.yaml │ │ │ ├── DUK_USE_DATE_FMT_STRFTIME.yaml │ │ │ ├── DUK_USE_DATE_FORMAT_STRING.yaml │ │ │ ├── DUK_USE_DATE_GET_LOCAL_TZOFFSET.yaml │ │ │ ├── DUK_USE_DATE_GET_NOW.yaml │ │ │ ├── DUK_USE_DATE_NOW_GETTIMEOFDAY.yaml │ │ │ ├── DUK_USE_DATE_NOW_TIME.yaml │ │ │ ├── DUK_USE_DATE_NOW_WINDOWS.yaml │ │ │ ├── DUK_USE_DATE_NOW_WINDOWS_SUBMS.yaml │ │ │ ├── DUK_USE_DATE_PARSE_STRING.yaml │ │ │ ├── DUK_USE_DATE_PRS_GETDATE.yaml │ │ │ ├── DUK_USE_DATE_PRS_STRPTIME.yaml │ │ │ ├── DUK_USE_DATE_TZO_GMTIME.yaml │ │ │ ├── DUK_USE_DATE_TZO_GMTIME_R.yaml │ │ │ ├── DUK_USE_DATE_TZO_GMTIME_S.yaml │ │ │ ├── DUK_USE_DATE_TZO_WINDOWS.yaml │ │ │ ├── DUK_USE_DATE_TZO_WINDOWS_NO_DST.yaml │ │ │ ├── DUK_USE_DDDPRINT.yaml │ │ │ ├── DUK_USE_DDPRINT.yaml │ │ │ ├── DUK_USE_DEBUG.yaml │ │ │ ├── DUK_USE_DEBUGGER_DUMPHEAP.yaml │ │ │ ├── DUK_USE_DEBUGGER_FWD_LOGGING.yaml │ │ │ ├── DUK_USE_DEBUGGER_FWD_PRINTALERT.yaml │ │ │ ├── DUK_USE_DEBUGGER_INSPECT.yaml │ │ │ ├── DUK_USE_DEBUGGER_PAUSE_UNCAUGHT.yaml │ │ │ ├── DUK_USE_DEBUGGER_SUPPORT.yaml │ │ │ ├── DUK_USE_DEBUGGER_THROW_NOTIFY.yaml │ │ │ ├── DUK_USE_DEBUGGER_TRANSPORT_TORTURE.yaml │ │ │ ├── DUK_USE_DEBUG_BUFSIZE.yaml │ │ │ ├── DUK_USE_DEBUG_LEVEL.yaml │ │ │ ├── DUK_USE_DEBUG_WRITE.yaml │ │ │ ├── DUK_USE_DEEP_C_STACK.yaml │ │ │ ├── DUK_USE_DOUBLE_BE.yaml │ │ │ ├── DUK_USE_DOUBLE_LE.yaml │ │ │ ├── DUK_USE_DOUBLE_LINKED_HEAP.yaml │ │ │ ├── DUK_USE_DOUBLE_ME.yaml │ │ │ ├── DUK_USE_DPRINT.yaml │ │ │ ├── DUK_USE_DPRINT_COLORS.yaml │ │ │ ├── DUK_USE_DPRINT_RDTSC.yaml │ │ │ ├── DUK_USE_DUKTAPE_BUILTIN.yaml │ │ │ ├── DUK_USE_ENCODING_BUILTINS.yaml │ │ │ ├── DUK_USE_ERRCREATE.yaml │ │ │ ├── DUK_USE_ERRTHROW.yaml │ │ │ ├── DUK_USE_ES6.yaml │ │ │ ├── DUK_USE_ES6_OBJECT_PROTO_PROPERTY.yaml │ │ │ ├── DUK_USE_ES6_OBJECT_SETPROTOTYPEOF.yaml │ │ │ ├── DUK_USE_ES6_PROXY.yaml │ │ │ ├── DUK_USE_ES6_REGEXP_BRACES.yaml │ │ │ ├── DUK_USE_ES6_REGEXP_SYNTAX.yaml │ │ │ ├── DUK_USE_ES6_UNICODE_ESCAPE.yaml │ │ │ ├── DUK_USE_ES7.yaml │ │ │ ├── DUK_USE_ES7_EXP_OPERATOR.yaml │ │ │ ├── DUK_USE_ES8.yaml │ │ │ ├── DUK_USE_ES9.yaml │ │ │ ├── DUK_USE_ESBC_LIMITS.yaml │ │ │ ├── DUK_USE_ESBC_MAX_BYTES.yaml │ │ │ ├── DUK_USE_ESBC_MAX_LINENUMBER.yaml │ │ │ ├── DUK_USE_EXAMPLE.yaml │ │ │ ├── DUK_USE_EXEC_FUN_LOCAL.yaml │ │ │ ├── DUK_USE_EXEC_INDIRECT_BOUND_CHECK.yaml │ │ │ ├── DUK_USE_EXEC_PREFER_SIZE.yaml │ │ │ ├── DUK_USE_EXEC_REGCONST_OPTIMIZE.yaml │ │ │ ├── DUK_USE_EXEC_TIMEOUT_CHECK.yaml │ │ │ ├── DUK_USE_EXPLICIT_NULL_INIT.yaml │ │ │ ├── DUK_USE_EXTSTR_FREE.yaml │ │ │ ├── DUK_USE_EXTSTR_INTERN_CHECK.yaml │ │ │ ├── DUK_USE_FASTINT.yaml │ │ │ ├── DUK_USE_FAST_REFCOUNT_DEFAULT.yaml │ │ │ ├── DUK_USE_FATAL_HANDLER.yaml │ │ │ ├── DUK_USE_FATAL_MAXLEN.yaml │ │ │ ├── DUK_USE_FILE_IO.yaml │ │ │ ├── DUK_USE_FINALIZER_SUPPORT.yaml │ │ │ ├── DUK_USE_FINALIZER_TORTURE.yaml │ │ │ ├── DUK_USE_FLEX_C99.yaml │ │ │ ├── DUK_USE_FLEX_ONESIZE.yaml │ │ │ ├── DUK_USE_FLEX_ZEROSIZE.yaml │ │ │ ├── DUK_USE_FULL_TVAL.yaml │ │ │ ├── DUK_USE_FUNCPTR16.yaml │ │ │ ├── DUK_USE_FUNCPTR_DEC16.yaml │ │ │ ├── DUK_USE_FUNCPTR_ENC16.yaml │ │ │ ├── DUK_USE_FUNCTION_BUILTIN.yaml │ │ │ ├── DUK_USE_FUNC_FILENAME_PROPERTY.yaml │ │ │ ├── DUK_USE_FUNC_NAME_PROPERTY.yaml │ │ │ ├── DUK_USE_GCC_PRAGMAS.yaml │ │ │ ├── DUK_USE_GC_TORTURE.yaml │ │ │ ├── DUK_USE_GET_MONOTONIC_TIME.yaml │ │ │ ├── DUK_USE_GET_MONOTONIC_TIME_CLOCK_GETTIME.yaml │ │ │ ├── DUK_USE_GET_MONOTONIC_TIME_WINDOWS_QPC.yaml │ │ │ ├── DUK_USE_GET_RANDOM_DOUBLE.yaml │ │ │ ├── DUK_USE_GLOBAL_BINDING.yaml │ │ │ ├── DUK_USE_GLOBAL_BUILTIN.yaml │ │ │ ├── DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS.yaml │ │ │ ├── DUK_USE_HEAPPTR16.yaml │ │ │ ├── DUK_USE_HEAPPTR_DEC16.yaml │ │ │ ├── DUK_USE_HEAPPTR_ENC16.yaml │ │ │ ├── DUK_USE_HEX_FASTPATH.yaml │ │ │ ├── DUK_USE_HEX_SUPPORT.yaml │ │ │ ├── DUK_USE_HOBJECT_ARRAY_ABANDON_LIMIT.yaml │ │ │ ├── DUK_USE_HOBJECT_ARRAY_ABANDON_MINSIZE.yaml │ │ │ ├── DUK_USE_HOBJECT_ARRAY_FAST_RESIZE_LIMIT.yaml │ │ │ ├── DUK_USE_HOBJECT_ARRAY_MINGROW_ADD.yaml │ │ │ ├── DUK_USE_HOBJECT_ARRAY_MINGROW_DIVISOR.yaml │ │ │ ├── DUK_USE_HOBJECT_ENTRY_MINGROW_ADD.yaml │ │ │ ├── DUK_USE_HOBJECT_ENTRY_MINGROW_DIVISOR.yaml │ │ │ ├── DUK_USE_HOBJECT_HASH_PART.yaml │ │ │ ├── DUK_USE_HOBJECT_HASH_PROP_LIMIT.yaml │ │ │ ├── DUK_USE_HOBJECT_LAYOUT_1.yaml │ │ │ ├── DUK_USE_HOBJECT_LAYOUT_2.yaml │ │ │ ├── DUK_USE_HOBJECT_LAYOUT_3.yaml │ │ │ ├── DUK_USE_HSTRING_ARRIDX.yaml │ │ │ ├── DUK_USE_HSTRING_CLEN.yaml │ │ │ ├── DUK_USE_HSTRING_EXTDATA.yaml │ │ │ ├── DUK_USE_HSTRING_LAZY_CLEN.yaml │ │ │ ├── DUK_USE_HTML_COMMENTS.yaml │ │ │ ├── DUK_USE_IDCHAR_FASTPATH.yaml │ │ │ ├── DUK_USE_INJECT_HEAP_ALLOC_ERROR.yaml │ │ │ ├── DUK_USE_INTEGER_BE.yaml │ │ │ ├── DUK_USE_INTEGER_LE.yaml │ │ │ ├── DUK_USE_INTEGER_ME.yaml │ │ │ ├── DUK_USE_INTERRUPT_COUNTER.yaml │ │ │ ├── DUK_USE_INTERRUPT_DEBUG_FIXUP.yaml │ │ │ ├── DUK_USE_JC.yaml │ │ │ ├── DUK_USE_JSON_BUILTIN.yaml │ │ │ ├── DUK_USE_JSON_DECNUMBER_FASTPATH.yaml │ │ │ ├── DUK_USE_JSON_DECSTRING_FASTPATH.yaml │ │ │ ├── DUK_USE_JSON_DEC_RECLIMIT.yaml │ │ │ ├── DUK_USE_JSON_EATWHITE_FASTPATH.yaml │ │ │ ├── DUK_USE_JSON_ENC_RECLIMIT.yaml │ │ │ ├── DUK_USE_JSON_QUOTESTRING_FASTPATH.yaml │ │ │ ├── DUK_USE_JSON_STRINGIFY_FASTPATH.yaml │ │ │ ├── DUK_USE_JSON_SUPPORT.yaml │ │ │ ├── DUK_USE_JX.yaml │ │ │ ├── DUK_USE_LEXER_SLIDING_WINDOW.yaml │ │ │ ├── DUK_USE_LIGHTFUNC_BUILTINS.yaml │ │ │ ├── DUK_USE_LITCACHE_SIZE.yaml │ │ │ ├── DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE.yaml │ │ │ ├── DUK_USE_MARK_AND_SWEEP.yaml │ │ │ ├── DUK_USE_MARK_AND_SWEEP_RECLIMIT.yaml │ │ │ ├── DUK_USE_MATH_BUILTIN.yaml │ │ │ ├── DUK_USE_MATH_FMAX.yaml │ │ │ ├── DUK_USE_MATH_FMIN.yaml │ │ │ ├── DUK_USE_MATH_ROUND.yaml │ │ │ ├── DUK_USE_MS_STRINGTABLE_RESIZE.yaml │ │ │ ├── DUK_USE_NATIVE_CALL_RECLIMIT.yaml │ │ │ ├── DUK_USE_NATIVE_STACK_CHECK.yaml │ │ │ ├── DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER.yaml │ │ │ ├── DUK_USE_NONSTD_ARRAY_MAP_TRAILER.yaml │ │ │ ├── DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT.yaml │ │ │ ├── DUK_USE_NONSTD_FUNC_CALLER_PROPERTY.yaml │ │ │ ├── DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY.yaml │ │ │ ├── DUK_USE_NONSTD_FUNC_STMT.yaml │ │ │ ├── DUK_USE_NONSTD_GETTER_KEY_ARGUMENT.yaml │ │ │ ├── DUK_USE_NONSTD_JSON_ESC_U2028_U2029.yaml │ │ │ ├── DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE.yaml │ │ │ ├── DUK_USE_NONSTD_SETTER_KEY_ARGUMENT.yaml │ │ │ ├── DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT.yaml │ │ │ ├── DUK_USE_NO_DOUBLE_ALIASING_SELFTEST.yaml │ │ │ ├── DUK_USE_NUMBER_BUILTIN.yaml │ │ │ ├── DUK_USE_OBJECT_BUILTIN.yaml │ │ │ ├── DUK_USE_OBJSIZES16.yaml │ │ │ ├── DUK_USE_OCTAL_SUPPORT.yaml │ │ │ ├── DUK_USE_OS_STRING.yaml │ │ │ ├── DUK_USE_PACKED_TVAL.yaml │ │ │ ├── DUK_USE_PACKED_TVAL_POSSIBLE.yaml │ │ │ ├── DUK_USE_PACK_CLANG_ATTR.yaml │ │ │ ├── DUK_USE_PACK_DUMMY_MEMBER.yaml │ │ │ ├── DUK_USE_PACK_GCC_ATTR.yaml │ │ │ ├── DUK_USE_PACK_MSVC_PRAGMA.yaml │ │ │ ├── DUK_USE_PANIC_ABORT.yaml │ │ │ ├── DUK_USE_PANIC_EXIT.yaml │ │ │ ├── DUK_USE_PANIC_HANDLER.yaml │ │ │ ├── DUK_USE_PANIC_SEGFAULT.yaml │ │ │ ├── DUK_USE_PARANOID_DATE_COMPUTATION.yaml │ │ │ ├── DUK_USE_PARANOID_ERRORS.yaml │ │ │ ├── DUK_USE_PARANOID_MATH.yaml │ │ │ ├── DUK_USE_PC2LINE.yaml │ │ │ ├── DUK_USE_PERFORMANCE_BUILTIN.yaml │ │ │ ├── DUK_USE_POW_NETBSD_WORKAROUND.yaml │ │ │ ├── DUK_USE_POW_WORKAROUNDS.yaml │ │ │ ├── DUK_USE_PREFER_SIZE.yaml │ │ │ ├── DUK_USE_PROMISE_BUILTIN.yaml │ │ │ ├── DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS.yaml │ │ │ ├── DUK_USE_RDTSC.yaml │ │ │ ├── DUK_USE_REFCOUNT16.yaml │ │ │ ├── DUK_USE_REFCOUNT32.yaml │ │ │ ├── DUK_USE_REFERENCE_COUNTING.yaml │ │ │ ├── DUK_USE_REFLECT_BUILTIN.yaml │ │ │ ├── DUK_USE_REFZERO_FINALIZER_TORTURE.yaml │ │ │ ├── DUK_USE_REGEXP_CANON_BITMAP.yaml │ │ │ ├── DUK_USE_REGEXP_CANON_WORKAROUND.yaml │ │ │ ├── DUK_USE_REGEXP_COMPILER_RECLIMIT.yaml │ │ │ ├── DUK_USE_REGEXP_EXECUTOR_RECLIMIT.yaml │ │ │ ├── DUK_USE_REGEXP_SUPPORT.yaml │ │ │ ├── DUK_USE_REPL_FPCLASSIFY.yaml │ │ │ ├── DUK_USE_REPL_ISFINITE.yaml │ │ │ ├── DUK_USE_REPL_ISINF.yaml │ │ │ ├── DUK_USE_REPL_ISNAN.yaml │ │ │ ├── DUK_USE_REPL_SIGNBIT.yaml │ │ │ ├── DUK_USE_ROM_GLOBAL_CLONE.yaml │ │ │ ├── DUK_USE_ROM_GLOBAL_INHERIT.yaml │ │ │ ├── DUK_USE_ROM_OBJECTS.yaml │ │ │ ├── DUK_USE_ROM_PTRCOMP_FIRST.yaml │ │ │ ├── DUK_USE_ROM_STRINGS.yaml │ │ │ ├── DUK_USE_SECTION_B.yaml │ │ │ ├── DUK_USE_SELF_TESTS.yaml │ │ │ ├── DUK_USE_SETJMP.yaml │ │ │ ├── DUK_USE_SHEBANG_COMMENTS.yaml │ │ │ ├── DUK_USE_SHUFFLE_TORTURE.yaml │ │ │ ├── DUK_USE_SIGSETJMP.yaml │ │ │ ├── DUK_USE_SOURCE_NONBMP.yaml │ │ │ ├── DUK_USE_STRHASH16.yaml │ │ │ ├── DUK_USE_STRHASH_DENSE.yaml │ │ │ ├── DUK_USE_STRHASH_SKIP_SHIFT.yaml │ │ │ ├── DUK_USE_STRICT_DECL.yaml │ │ │ ├── DUK_USE_STRICT_UTF8_SOURCE.yaml │ │ │ ├── DUK_USE_STRING_BUILTIN.yaml │ │ │ ├── DUK_USE_STRLEN16.yaml │ │ │ ├── DUK_USE_STRTAB_CHAIN.yaml │ │ │ ├── DUK_USE_STRTAB_CHAIN_SIZE.yaml │ │ │ ├── DUK_USE_STRTAB_GROW_LIMIT.yaml │ │ │ ├── DUK_USE_STRTAB_MAXSIZE.yaml │ │ │ ├── DUK_USE_STRTAB_MINSIZE.yaml │ │ │ ├── DUK_USE_STRTAB_PROBE.yaml │ │ │ ├── DUK_USE_STRTAB_PTRCOMP.yaml │ │ │ ├── DUK_USE_STRTAB_RESIZE_CHECK_MASK.yaml │ │ │ ├── DUK_USE_STRTAB_SHRINK_LIMIT.yaml │ │ │ ├── DUK_USE_STRTAB_TORTURE.yaml │ │ │ ├── DUK_USE_SYMBOL_BUILTIN.yaml │ │ │ ├── DUK_USE_TAILCALL.yaml │ │ │ ├── DUK_USE_TARGET_INFO.yaml │ │ │ ├── DUK_USE_TRACEBACKS.yaml │ │ │ ├── DUK_USE_TRACEBACK_DEPTH.yaml │ │ │ ├── DUK_USE_UNALIGNED_ACCESSES_POSSIBLE.yaml │ │ │ ├── DUK_USE_UNDERSCORE_SETJMP.yaml │ │ │ ├── DUK_USE_UNION_INITIALIZERS.yaml │ │ │ ├── DUK_USE_USER_DECLARE.yaml │ │ │ ├── DUK_USE_USER_INITJS.yaml │ │ │ ├── DUK_USE_VALSTACK_GROW_SHIFT.yaml │ │ │ ├── DUK_USE_VALSTACK_LIMIT.yaml │ │ │ ├── DUK_USE_VALSTACK_SHRINK_CHECK_SHIFT.yaml │ │ │ ├── DUK_USE_VALSTACK_SHRINK_SLACK_SHIFT.yaml │ │ │ ├── DUK_USE_VALSTACK_UNSAFE.yaml │ │ │ ├── DUK_USE_VARIADIC_MACROS.yaml │ │ │ ├── DUK_USE_VERBOSE_ERRORS.yaml │ │ │ ├── DUK_USE_VERBOSE_EXECUTOR_ERRORS.yaml │ │ │ ├── DUK_USE_VOLUNTARY_GC.yaml │ │ │ └── DUK_USE_ZERO_BUFFER_DATA.yaml │ │ ├── examples │ │ │ ├── compliance.yaml │ │ │ ├── debugger_support.yaml │ │ │ ├── disable_bufferobjects.yaml │ │ │ ├── disable_es6.yaml │ │ │ ├── enable_debug_print0.yaml │ │ │ ├── enable_debug_print1.yaml │ │ │ ├── enable_debug_print2.yaml │ │ │ ├── enable_fastint.yaml │ │ │ ├── low_memory.yaml │ │ │ ├── low_memory_strip.yaml │ │ │ ├── performance_sensitive.yaml │ │ │ ├── rom_builtins.yaml │ │ │ ├── security_sensitive.yaml │ │ │ ├── shallow_c_stack.yaml │ │ │ └── timing_sensitive.yaml │ │ ├── feature-options │ │ │ ├── DUK_OPT_ASSERTIONS.yaml │ │ │ ├── DUK_OPT_BUFFEROBJECT_SUPPORT.yaml │ │ │ ├── DUK_OPT_BUFLEN16.yaml │ │ │ ├── DUK_OPT_DATAPTR16.yaml │ │ │ ├── DUK_OPT_DATAPTR_DEC16.yaml │ │ │ ├── DUK_OPT_DATAPTR_ENC16.yaml │ │ │ ├── DUK_OPT_DDDPRINT.yaml │ │ │ ├── DUK_OPT_DDPRINT.yaml │ │ │ ├── DUK_OPT_DEBUG.yaml │ │ │ ├── DUK_OPT_DEBUGGER_DUMPHEAP.yaml │ │ │ ├── DUK_OPT_DEBUGGER_FWD_LOGGING.yaml │ │ │ ├── DUK_OPT_DEBUGGER_FWD_PRINTALERT.yaml │ │ │ ├── DUK_OPT_DEBUGGER_SUPPORT.yaml │ │ │ ├── DUK_OPT_DEBUGGER_TRANSPORT_TORTURE.yaml │ │ │ ├── DUK_OPT_DEBUG_BUFSIZE.yaml │ │ │ ├── DUK_OPT_DECLARE.yaml │ │ │ ├── DUK_OPT_DEEP_C_STACK.yaml │ │ │ ├── DUK_OPT_DLL_BUILD.yaml │ │ │ ├── DUK_OPT_DPRINT.yaml │ │ │ ├── DUK_OPT_DPRINT_COLORS.yaml │ │ │ ├── DUK_OPT_DPRINT_RDTSC.yaml │ │ │ ├── DUK_OPT_EXAMPLE.yaml │ │ │ ├── DUK_OPT_EXEC_TIMEOUT_CHECK.yaml │ │ │ ├── DUK_OPT_EXTERNAL_STRINGS.yaml │ │ │ ├── DUK_OPT_EXTSTR_FREE.yaml │ │ │ ├── DUK_OPT_EXTSTR_INTERN_CHECK.yaml │ │ │ ├── DUK_OPT_FASTINT.yaml │ │ │ ├── DUK_OPT_FORCE_ALIGN.yaml │ │ │ ├── DUK_OPT_FORCE_BYTEORDER.yaml │ │ │ ├── DUK_OPT_FUNCPTR16.yaml │ │ │ ├── DUK_OPT_FUNCPTR_DEC16.yaml │ │ │ ├── DUK_OPT_FUNCPTR_ENC16.yaml │ │ │ ├── DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY.yaml │ │ │ ├── DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY.yaml │ │ │ ├── DUK_OPT_GC_TORTURE.yaml │ │ │ ├── DUK_OPT_HAVE_CUSTOM_H.yaml │ │ │ ├── DUK_OPT_HEAPPTR16.yaml │ │ │ ├── DUK_OPT_HEAPPTR_DEC16.yaml │ │ │ ├── DUK_OPT_HEAPPTR_ENC16.yaml │ │ │ ├── DUK_OPT_INTERRUPT_COUNTER.yaml │ │ │ ├── DUK_OPT_JSON_STRINGIFY_FASTPATH.yaml │ │ │ ├── DUK_OPT_LIGHTFUNC_BUILTINS.yaml │ │ │ ├── DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY.yaml │ │ │ ├── DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY.yaml │ │ │ ├── DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT.yaml │ │ │ ├── DUK_OPT_NO_AUGMENT_ERRORS.yaml │ │ │ ├── DUK_OPT_NO_BROWSER_LIKE.yaml │ │ │ ├── DUK_OPT_NO_BUFFEROBJECT_SUPPORT.yaml │ │ │ ├── DUK_OPT_NO_BYTECODE_DUMP_SUPPORT.yaml │ │ │ ├── DUK_OPT_NO_COMMONJS_MODULES.yaml │ │ │ ├── DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY.yaml │ │ │ ├── DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF.yaml │ │ │ ├── DUK_OPT_NO_ES6_PROXY.yaml │ │ │ ├── DUK_OPT_NO_FILE_IO.yaml │ │ │ ├── DUK_OPT_NO_FUNC_STMT.yaml │ │ │ ├── DUK_OPT_NO_JC.yaml │ │ │ ├── DUK_OPT_NO_JSONC.yaml │ │ │ ├── DUK_OPT_NO_JSONX.yaml │ │ │ ├── DUK_OPT_NO_JX.yaml │ │ │ ├── DUK_OPT_NO_MARK_AND_SWEEP.yaml │ │ │ ├── DUK_OPT_NO_MS_STRINGTABLE_RESIZE.yaml │ │ │ ├── DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT.yaml │ │ │ ├── DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER.yaml │ │ │ ├── DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER.yaml │ │ │ ├── DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT.yaml │ │ │ ├── DUK_OPT_NO_NONSTD_FUNC_STMT.yaml │ │ │ ├── DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029.yaml │ │ │ ├── DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT.yaml │ │ │ ├── DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY.yaml │ │ │ ├── DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF.yaml │ │ │ ├── DUK_OPT_NO_OCTAL_SUPPORT.yaml │ │ │ ├── DUK_OPT_NO_PACKED_TVAL.yaml │ │ │ ├── DUK_OPT_NO_PC2LINE.yaml │ │ │ ├── DUK_OPT_NO_REFERENCE_COUNTING.yaml │ │ │ ├── DUK_OPT_NO_REGEXP_SUPPORT.yaml │ │ │ ├── DUK_OPT_NO_SECTION_B.yaml │ │ │ ├── DUK_OPT_NO_SOURCE_NONBMP.yaml │ │ │ ├── DUK_OPT_NO_STRICT_DECL.yaml │ │ │ ├── DUK_OPT_NO_TRACEBACKS.yaml │ │ │ ├── DUK_OPT_NO_VERBOSE_ERRORS.yaml │ │ │ ├── DUK_OPT_NO_VOLUNTARY_GC.yaml │ │ │ ├── DUK_OPT_NO_ZERO_BUFFER_DATA.yaml │ │ │ ├── DUK_OPT_OBJSIZES16.yaml │ │ │ ├── DUK_OPT_PANIC_HANDLER.yaml │ │ │ ├── DUK_OPT_REFCOUNT16.yaml │ │ │ ├── DUK_OPT_SEGFAULT_ON_PANIC.yaml │ │ │ ├── DUK_OPT_SELF_TESTS.yaml │ │ │ ├── DUK_OPT_SETJMP.yaml │ │ │ ├── DUK_OPT_SHUFFLE_TORTURE.yaml │ │ │ ├── DUK_OPT_SIGSETJMP.yaml │ │ │ ├── DUK_OPT_STRHASH16.yaml │ │ │ ├── DUK_OPT_STRICT_UTF8_SOURCE.yaml │ │ │ ├── DUK_OPT_STRLEN16.yaml │ │ │ ├── DUK_OPT_STRTAB_CHAIN.yaml │ │ │ ├── DUK_OPT_STRTAB_CHAIN_SIZE.yaml │ │ │ ├── DUK_OPT_TARGET_INFO.yaml │ │ │ ├── DUK_OPT_TRACEBACK_DEPTH.yaml │ │ │ ├── DUK_OPT_UNDERSCORE_SETJMP.yaml │ │ │ └── DUK_OPT_USER_INITJS.yaml │ │ ├── header-snippets │ │ │ ├── 64bitops.h.in │ │ │ ├── alignment_fillin.h.in │ │ │ ├── architecture_fillins.h.in │ │ │ ├── byteorder_derived.h.in │ │ │ ├── byteorder_fillin.h.in │ │ │ ├── compiler_fillins.h.in │ │ │ ├── cpp_exception_sanity.h.in │ │ │ ├── date_provider.h.in │ │ │ ├── gcc_clang_visibility.h.in │ │ │ ├── inline_workaround.h.in │ │ │ ├── msvc_visibility.h.in │ │ │ ├── object_layout.h.in │ │ │ ├── packed_tval_fillin.h.in │ │ │ ├── platform_conditionalincludes.h.in │ │ │ ├── platform_cppextras.h.in │ │ │ ├── platform_fillins.h.in │ │ │ ├── platform_sharedincludes.h.in │ │ │ ├── reject_fast_math.h.in │ │ │ ├── types1.h.in │ │ │ ├── types2.h.in │ │ │ ├── types_c99.h.in │ │ │ └── types_legacy.h.in │ │ ├── helper-snippets │ │ │ ├── DUK_F_AIX.h.in │ │ │ ├── DUK_F_AMIGAOS.h.in │ │ │ ├── DUK_F_ANDROID.h.in │ │ │ ├── DUK_F_APPLE.h.in │ │ │ ├── DUK_F_ARM.h.in │ │ │ ├── DUK_F_BCC.h.in │ │ │ ├── DUK_F_BSD.h.in │ │ │ ├── DUK_F_C99.h.in │ │ │ ├── DUK_F_CLANG.h.in │ │ │ ├── DUK_F_CPP.h.in │ │ │ ├── DUK_F_CPP11.h.in │ │ │ ├── DUK_F_CYGWIN.h.in │ │ │ ├── DUK_F_DURANGO.h.in │ │ │ ├── DUK_F_EMSCRIPTEN.h.in │ │ │ ├── DUK_F_FLASHPLAYER.h.in │ │ │ ├── DUK_F_FREEBSD.h.in │ │ │ ├── DUK_F_GCC.h.in │ │ │ ├── DUK_F_HPUX.h.in │ │ │ ├── DUK_F_LINUX.h.in │ │ │ ├── DUK_F_M68K.h.in │ │ │ ├── DUK_F_MINGW.h.in │ │ │ ├── DUK_F_MINT.h.in │ │ │ ├── DUK_F_MIPS.h.in │ │ │ ├── DUK_F_MSVC.h.in │ │ │ ├── DUK_F_NETBSD.h.in │ │ │ ├── DUK_F_NO_STDINT_H.h.in │ │ │ ├── DUK_F_OPENBSD.h.in │ │ │ ├── DUK_F_ORBIS.h.in │ │ │ ├── DUK_F_POSIX.h.in │ │ │ ├── DUK_F_PPC.h.in │ │ │ ├── DUK_F_QNX.h.in │ │ │ ├── DUK_F_RISCV.h.in │ │ │ ├── DUK_F_SPARC.h.in │ │ │ ├── DUK_F_SUN.h.in │ │ │ ├── DUK_F_SUPERH.h.in │ │ │ ├── DUK_F_TINSPIRE.h.in │ │ │ ├── DUK_F_TINYC.h.in │ │ │ ├── DUK_F_TOS.h.in │ │ │ ├── DUK_F_UCLIBC.h.in │ │ │ ├── DUK_F_ULL_CONSTS.h.in │ │ │ ├── DUK_F_UNIX.h.in │ │ │ ├── DUK_F_VBCC.h.in │ │ │ ├── DUK_F_WINDOWS.h.in │ │ │ └── DUK_F_X86.h.in │ │ ├── platforms.yaml │ │ ├── platforms │ │ │ ├── platform_aix.h.in │ │ │ ├── platform_amigaos.h.in │ │ │ ├── platform_android.h.in │ │ │ ├── platform_apple.h.in │ │ │ ├── platform_cygwin.h.in │ │ │ ├── platform_durango.h.in │ │ │ ├── platform_emscripten.h.in │ │ │ ├── platform_flashplayer.h.in │ │ │ ├── platform_generic.h.in │ │ │ ├── platform_genericbsd.h.in │ │ │ ├── platform_genericunix.h.in │ │ │ ├── platform_hpux.h.in │ │ │ ├── platform_linux.h.in │ │ │ ├── platform_openbsd.h.in │ │ │ ├── platform_orbis.h.in │ │ │ ├── platform_posix.h.in │ │ │ ├── platform_qnx.h.in │ │ │ ├── platform_solaris.h.in │ │ │ ├── platform_tinspire.h.in │ │ │ ├── platform_tos.h.in │ │ │ └── platform_windows.h.in │ │ └── tags.yaml │ ├── debugger │ │ ├── Makefile │ │ ├── README.rst │ │ ├── duk_classnames.yaml │ │ ├── duk_debug.js │ │ ├── duk_debug_meta.json │ │ ├── duk_debug_proxy.js │ │ ├── duk_debugcommands.yaml │ │ ├── duk_debugerrors.yaml │ │ ├── duk_opcodes.yaml │ │ ├── package.json │ │ └── static │ │ │ ├── index.html │ │ │ ├── style.css │ │ │ └── webui.js │ ├── duk_dist_meta.json │ ├── examples │ │ ├── README.rst │ │ ├── alloc-hybrid │ │ │ ├── README.rst │ │ │ ├── duk_alloc_hybrid.c │ │ │ └── duk_alloc_hybrid.h │ │ ├── alloc-logging │ │ │ ├── README.rst │ │ │ ├── duk_alloc_logging.c │ │ │ ├── duk_alloc_logging.h │ │ │ └── log2gnuplot.py │ │ ├── alloc-torture │ │ │ ├── README.rst │ │ │ ├── duk_alloc_torture.c │ │ │ └── duk_alloc_torture.h │ │ ├── cmdline │ │ │ ├── README.rst │ │ │ ├── duk_cmdline.c │ │ │ ├── duk_cmdline.h │ │ │ └── duk_cmdline_lowmem.c │ │ ├── codepage-conv │ │ │ ├── README.rst │ │ │ ├── duk_codepage_conv.c │ │ │ ├── duk_codepage_conv.h │ │ │ └── test.c │ │ ├── coffee │ │ │ ├── README.rst │ │ │ ├── globals.coffee │ │ │ ├── hello.coffee │ │ │ └── mandel.coffee │ │ ├── cpp-exceptions │ │ │ ├── README.rst │ │ │ └── cpp_exceptions.cpp │ │ ├── debug-trans-dvalue │ │ │ ├── Makefile │ │ │ ├── README.rst │ │ │ ├── duk_trans_dvalue.c │ │ │ ├── duk_trans_dvalue.h │ │ │ └── test.c │ │ ├── debug-trans-socket │ │ │ ├── README.rst │ │ │ ├── duk_trans_socket.h │ │ │ ├── duk_trans_socket_unix.c │ │ │ └── duk_trans_socket_windows.c │ │ ├── dummy-date-provider │ │ │ ├── README.rst │ │ │ └── dummy_date_provider.c │ │ ├── eval │ │ │ ├── README.rst │ │ │ └── eval.c │ │ ├── eventloop │ │ │ ├── README.rst │ │ │ ├── basic-test.js │ │ │ ├── c_eventloop.c │ │ │ ├── c_eventloop.h │ │ │ ├── c_eventloop.js │ │ │ ├── client-socket-test.js │ │ │ ├── ecma_eventloop.js │ │ │ ├── fileio.c │ │ │ ├── main.c │ │ │ ├── poll.c │ │ │ ├── server-socket-test.js │ │ │ ├── socket.c │ │ │ └── timer-test.js │ │ ├── guide │ │ │ ├── README.rst │ │ │ ├── fib.js │ │ │ ├── prime.js │ │ │ ├── primecheck.c │ │ │ ├── process.js │ │ │ ├── processlines.c │ │ │ └── uppercase.c │ │ ├── hello │ │ │ ├── README.rst │ │ │ └── hello.c │ │ ├── jxpretty │ │ │ ├── README.rst │ │ │ └── jxpretty.c │ │ └── sandbox │ │ │ ├── README.rst │ │ │ └── sandbox.c │ ├── extras │ │ ├── README.rst │ │ ├── alloc-pool │ │ │ ├── Makefile │ │ │ ├── README.rst │ │ │ ├── duk_alloc_pool.c │ │ │ ├── duk_alloc_pool.h │ │ │ ├── ptrcomp.yaml │ │ │ ├── ptrcomp_fixup.h │ │ │ └── test.c │ │ ├── cbor │ │ │ ├── Makefile │ │ │ ├── README.rst │ │ │ ├── cbordecode.py │ │ │ ├── duk_cbor.c │ │ │ ├── duk_cbor.h │ │ │ ├── jsoncbor.c │ │ │ └── run_testvectors.js │ │ ├── console │ │ │ ├── Makefile │ │ │ ├── README.rst │ │ │ ├── duk_console.c │ │ │ ├── duk_console.h │ │ │ └── test.c │ │ ├── duk-v1-compat │ │ │ ├── Makefile │ │ │ ├── README.rst │ │ │ ├── duk_v1_compat.c │ │ │ ├── duk_v1_compat.h │ │ │ ├── test.c │ │ │ ├── test_compile1.js │ │ │ ├── test_compile2.js │ │ │ ├── test_eval1.js │ │ │ └── test_eval2.js │ │ ├── logging │ │ │ ├── Makefile │ │ │ ├── README.rst │ │ │ ├── duk_logging.c │ │ │ ├── duk_logging.h │ │ │ └── test.c │ │ ├── minimal-printf │ │ │ ├── Makefile │ │ │ ├── README.rst │ │ │ ├── duk_minimal_printf.c │ │ │ ├── duk_minimal_printf.h │ │ │ └── test.c │ │ ├── module-duktape │ │ │ ├── Makefile │ │ │ ├── README.rst │ │ │ ├── duk_module_duktape.c │ │ │ ├── duk_module_duktape.h │ │ │ └── test.c │ │ ├── module-node │ │ │ ├── Makefile │ │ │ ├── README.rst │ │ │ ├── duk_module_node.c │ │ │ ├── duk_module_node.h │ │ │ └── test.c │ │ └── print-alert │ │ │ ├── Makefile │ │ │ ├── README.rst │ │ │ ├── duk_print_alert.c │ │ │ ├── duk_print_alert.h │ │ │ └── test.c │ ├── licenses │ │ ├── commonjs.txt │ │ ├── lua.txt │ │ ├── murmurhash2.txt │ │ ├── splitmix64.txt │ │ └── xoroshiro128plus.txt │ ├── mandel.js │ ├── polyfills │ │ ├── console-minimal.js │ │ ├── duktape-buffer.js │ │ ├── duktape-error-setter-nonwritable.js │ │ ├── duktape-error-setter-writable.js │ │ ├── duktape-isfastint.js │ │ ├── global.js │ │ ├── object-assign.js │ │ ├── object-prototype-definegetter.js │ │ ├── object-prototype-definesetter.js │ │ ├── performance-now.js │ │ └── promise.js │ ├── src-input │ │ ├── SpecialCasing-8bit.txt │ │ ├── SpecialCasing.txt │ │ ├── UnicodeData-8bit.txt │ │ ├── UnicodeData.txt │ │ ├── builtins.yaml │ │ ├── duk_alloc_default.c │ │ ├── duk_api_buffer.c │ │ ├── duk_api_bytecode.c │ │ ├── duk_api_call.c │ │ ├── duk_api_codec.c │ │ ├── duk_api_compile.c │ │ ├── duk_api_debug.c │ │ ├── duk_api_heap.c │ │ ├── duk_api_inspect.c │ │ ├── duk_api_internal.h │ │ ├── duk_api_memory.c │ │ ├── duk_api_object.c │ │ ├── duk_api_random.c │ │ ├── duk_api_stack.c │ │ ├── duk_api_string.c │ │ ├── duk_api_time.c │ │ ├── duk_bi_array.c │ │ ├── duk_bi_boolean.c │ │ ├── duk_bi_buffer.c │ │ ├── duk_bi_cbor.c │ │ ├── duk_bi_date.c │ │ ├── duk_bi_date_unix.c │ │ ├── duk_bi_date_windows.c │ │ ├── duk_bi_duktape.c │ │ ├── duk_bi_encoding.c │ │ ├── duk_bi_error.c │ │ ├── duk_bi_function.c │ │ ├── duk_bi_global.c │ │ ├── duk_bi_json.c │ │ ├── duk_bi_math.c │ │ ├── duk_bi_number.c │ │ ├── duk_bi_object.c │ │ ├── duk_bi_performance.c │ │ ├── duk_bi_pointer.c │ │ ├── duk_bi_promise.c │ │ ├── duk_bi_protos.h │ │ ├── duk_bi_proxy.c │ │ ├── duk_bi_reflect.c │ │ ├── duk_bi_regexp.c │ │ ├── duk_bi_string.c │ │ ├── duk_bi_symbol.c │ │ ├── duk_bi_thread.c │ │ ├── duk_bi_thrower.c │ │ ├── duk_dblunion.h │ │ ├── duk_debug.h │ │ ├── duk_debug_fixedbuffer.c │ │ ├── duk_debug_macros.c │ │ ├── duk_debug_vsnprintf.c │ │ ├── duk_debugger.c │ │ ├── duk_debugger.h │ │ ├── duk_error.h │ │ ├── duk_error_augment.c │ │ ├── duk_error_longjmp.c │ │ ├── duk_error_macros.c │ │ ├── duk_error_misc.c │ │ ├── duk_error_throw.c │ │ ├── duk_exception.h │ │ ├── duk_fltunion.h │ │ ├── duk_forwdecl.h │ │ ├── duk_harray.h │ │ ├── duk_hboundfunc.h │ │ ├── duk_hbuffer.h │ │ ├── duk_hbuffer_alloc.c │ │ ├── duk_hbuffer_assert.c │ │ ├── duk_hbuffer_ops.c │ │ ├── duk_hbufobj.h │ │ ├── duk_hbufobj_misc.c │ │ ├── duk_hcompfunc.h │ │ ├── duk_heap.h │ │ ├── duk_heap_alloc.c │ │ ├── duk_heap_finalize.c │ │ ├── duk_heap_hashstring.c │ │ ├── duk_heap_markandsweep.c │ │ ├── duk_heap_memory.c │ │ ├── duk_heap_misc.c │ │ ├── duk_heap_refcount.c │ │ ├── duk_heap_stringcache.c │ │ ├── duk_heap_stringtable.c │ │ ├── duk_heaphdr.h │ │ ├── duk_heaphdr_assert.c │ │ ├── duk_henv.h │ │ ├── duk_hnatfunc.h │ │ ├── duk_hobject.h │ │ ├── duk_hobject_alloc.c │ │ ├── duk_hobject_assert.c │ │ ├── duk_hobject_class.c │ │ ├── duk_hobject_enum.c │ │ ├── duk_hobject_misc.c │ │ ├── duk_hobject_pc2line.c │ │ ├── duk_hobject_props.c │ │ ├── duk_hproxy.h │ │ ├── duk_hstring.h │ │ ├── duk_hstring_assert.c │ │ ├── duk_hstring_misc.c │ │ ├── duk_hthread.h │ │ ├── duk_hthread_alloc.c │ │ ├── duk_hthread_builtins.c │ │ ├── duk_hthread_misc.c │ │ ├── duk_hthread_stacks.c │ │ ├── duk_internal.h │ │ ├── duk_jmpbuf.h │ │ ├── duk_js.h │ │ ├── duk_js_arith.c │ │ ├── duk_js_bytecode.h │ │ ├── duk_js_call.c │ │ ├── duk_js_compiler.c │ │ ├── duk_js_compiler.h │ │ ├── duk_js_executor.c │ │ ├── duk_js_ops.c │ │ ├── duk_js_var.c │ │ ├── duk_json.h │ │ ├── duk_lexer.c │ │ ├── duk_lexer.h │ │ ├── duk_numconv.c │ │ ├── duk_numconv.h │ │ ├── duk_refcount.h │ │ ├── duk_regexp.h │ │ ├── duk_regexp_compiler.c │ │ ├── duk_regexp_executor.c │ │ ├── duk_replacements.c │ │ ├── duk_replacements.h │ │ ├── duk_selftest.c │ │ ├── duk_selftest.h │ │ ├── duk_strings.h │ │ ├── duk_tval.c │ │ ├── duk_tval.h │ │ ├── duk_unicode.h │ │ ├── duk_unicode_support.c │ │ ├── duk_unicode_tables.c │ │ ├── duk_util.h │ │ ├── duk_util_bitdecoder.c │ │ ├── duk_util_bitencoder.c │ │ ├── duk_util_bufwriter.c │ │ ├── duk_util_cast.c │ │ ├── duk_util_double.c │ │ ├── duk_util_hashbytes.c │ │ ├── duk_util_memory.c │ │ ├── duk_util_memrw.c │ │ ├── duk_util_misc.c │ │ ├── duk_util_tinyrandom.c │ │ ├── duktape.h.in │ │ └── strings.yaml │ ├── src-noline │ │ ├── duk_config.h │ │ ├── duk_source_meta.json │ │ ├── duktape.c │ │ └── duktape.h │ ├── src-separate │ │ ├── duk_alloc_default.c │ │ ├── duk_api_buffer.c │ │ ├── duk_api_bytecode.c │ │ ├── duk_api_call.c │ │ ├── duk_api_codec.c │ │ ├── duk_api_compile.c │ │ ├── duk_api_debug.c │ │ ├── duk_api_heap.c │ │ ├── duk_api_inspect.c │ │ ├── duk_api_internal.h │ │ ├── duk_api_memory.c │ │ ├── duk_api_object.c │ │ ├── duk_api_random.c │ │ ├── duk_api_stack.c │ │ ├── duk_api_string.c │ │ ├── duk_api_time.c │ │ ├── duk_bi_array.c │ │ ├── duk_bi_boolean.c │ │ ├── duk_bi_buffer.c │ │ ├── duk_bi_cbor.c │ │ ├── duk_bi_date.c │ │ ├── duk_bi_date_unix.c │ │ ├── duk_bi_date_windows.c │ │ ├── duk_bi_duktape.c │ │ ├── duk_bi_encoding.c │ │ ├── duk_bi_error.c │ │ ├── duk_bi_function.c │ │ ├── duk_bi_global.c │ │ ├── duk_bi_json.c │ │ ├── duk_bi_math.c │ │ ├── duk_bi_number.c │ │ ├── duk_bi_object.c │ │ ├── duk_bi_performance.c │ │ ├── duk_bi_pointer.c │ │ ├── duk_bi_promise.c │ │ ├── duk_bi_protos.h │ │ ├── duk_bi_proxy.c │ │ ├── duk_bi_reflect.c │ │ ├── duk_bi_regexp.c │ │ ├── duk_bi_string.c │ │ ├── duk_bi_symbol.c │ │ ├── duk_bi_thread.c │ │ ├── duk_bi_thrower.c │ │ ├── duk_builtins.c │ │ ├── duk_builtins.h │ │ ├── duk_config.h │ │ ├── duk_dblunion.h │ │ ├── duk_debug.h │ │ ├── duk_debug_fixedbuffer.c │ │ ├── duk_debug_macros.c │ │ ├── duk_debug_vsnprintf.c │ │ ├── duk_debugger.c │ │ ├── duk_debugger.h │ │ ├── duk_error.h │ │ ├── duk_error_augment.c │ │ ├── duk_error_longjmp.c │ │ ├── duk_error_macros.c │ │ ├── duk_error_misc.c │ │ ├── duk_error_throw.c │ │ ├── duk_exception.h │ │ ├── duk_fltunion.h │ │ ├── duk_forwdecl.h │ │ ├── duk_harray.h │ │ ├── duk_hboundfunc.h │ │ ├── duk_hbuffer.h │ │ ├── duk_hbuffer_alloc.c │ │ ├── duk_hbuffer_assert.c │ │ ├── duk_hbuffer_ops.c │ │ ├── duk_hbufobj.h │ │ ├── duk_hbufobj_misc.c │ │ ├── duk_hcompfunc.h │ │ ├── duk_heap.h │ │ ├── duk_heap_alloc.c │ │ ├── duk_heap_finalize.c │ │ ├── duk_heap_hashstring.c │ │ ├── duk_heap_markandsweep.c │ │ ├── duk_heap_memory.c │ │ ├── duk_heap_misc.c │ │ ├── duk_heap_refcount.c │ │ ├── duk_heap_stringcache.c │ │ ├── duk_heap_stringtable.c │ │ ├── duk_heaphdr.h │ │ ├── duk_heaphdr_assert.c │ │ ├── duk_henv.h │ │ ├── duk_hnatfunc.h │ │ ├── duk_hobject.h │ │ ├── duk_hobject_alloc.c │ │ ├── duk_hobject_assert.c │ │ ├── duk_hobject_class.c │ │ ├── duk_hobject_enum.c │ │ ├── duk_hobject_misc.c │ │ ├── duk_hobject_pc2line.c │ │ ├── duk_hobject_props.c │ │ ├── duk_hproxy.h │ │ ├── duk_hstring.h │ │ ├── duk_hstring_assert.c │ │ ├── duk_hstring_misc.c │ │ ├── duk_hthread.h │ │ ├── duk_hthread_alloc.c │ │ ├── duk_hthread_builtins.c │ │ ├── duk_hthread_misc.c │ │ ├── duk_hthread_stacks.c │ │ ├── duk_internal.h │ │ ├── duk_jmpbuf.h │ │ ├── duk_js.h │ │ ├── duk_js_arith.c │ │ ├── duk_js_bytecode.h │ │ ├── duk_js_call.c │ │ ├── duk_js_compiler.c │ │ ├── duk_js_compiler.h │ │ ├── duk_js_executor.c │ │ ├── duk_js_ops.c │ │ ├── duk_js_var.c │ │ ├── duk_json.h │ │ ├── duk_lexer.c │ │ ├── duk_lexer.h │ │ ├── duk_numconv.c │ │ ├── duk_numconv.h │ │ ├── duk_refcount.h │ │ ├── duk_regexp.h │ │ ├── duk_regexp_compiler.c │ │ ├── duk_regexp_executor.c │ │ ├── duk_replacements.c │ │ ├── duk_replacements.h │ │ ├── duk_selftest.c │ │ ├── duk_selftest.h │ │ ├── duk_source_meta.json │ │ ├── duk_strings.h │ │ ├── duk_tval.c │ │ ├── duk_tval.h │ │ ├── duk_unicode.h │ │ ├── duk_unicode_support.c │ │ ├── duk_unicode_tables.c │ │ ├── duk_util.h │ │ ├── duk_util_bitdecoder.c │ │ ├── duk_util_bitencoder.c │ │ ├── duk_util_bufwriter.c │ │ ├── duk_util_cast.c │ │ ├── duk_util_double.c │ │ ├── duk_util_hashbytes.c │ │ ├── duk_util_memory.c │ │ ├── duk_util_memrw.c │ │ ├── duk_util_misc.c │ │ ├── duk_util_tinyrandom.c │ │ └── duktape.h │ ├── src │ │ ├── duk_config.h │ │ ├── duk_source_meta.json │ │ ├── duktape.c │ │ └── duktape.h │ └── tools │ │ ├── combine_src.py │ │ ├── configure.py │ │ ├── create_spdx_license.py │ │ ├── duk_meta_to_strarray.py │ │ ├── dukutil.py │ │ ├── dump_bytecode.py │ │ ├── extract_caseconv.py │ │ ├── extract_chars.py │ │ ├── extract_unique_options.py │ │ ├── genbuiltins.py │ │ ├── genconfig.py │ │ ├── json2yaml.py │ │ ├── merge_debug_meta.py │ │ ├── prepare_unicode_data.py │ │ ├── resolve_combined_lineno.py │ │ ├── scan_strings.py │ │ ├── scan_used_stridx_bidx.py │ │ └── yaml2json.py ├── libuv │ ├── .gitattributes │ ├── .github │ │ ├── ISSUE_TEMPLATE.md │ │ ├── stale.yml │ │ └── workflows │ │ │ ├── CI.yml │ │ │ └── sanitizer.yml │ ├── .gitignore │ ├── .mailmap │ ├── AUTHORS │ ├── CMakeLists.txt │ ├── CONTRIBUTING.md │ ├── ChangeLog │ ├── LICENSE │ ├── LICENSE-docs │ ├── MAINTAINERS.md │ ├── Makefile.am │ ├── README.md │ ├── SUPPORTED_PLATFORMS.md │ ├── autogen.sh │ ├── configure.ac │ ├── docs │ │ ├── code │ │ │ ├── cgi │ │ │ │ ├── main.c │ │ │ │ └── tick.c │ │ │ ├── detach │ │ │ │ └── main.c │ │ │ ├── dns │ │ │ │ └── main.c │ │ │ ├── helloworld │ │ │ │ └── main.c │ │ │ ├── idle-basic │ │ │ │ └── main.c │ │ │ ├── idle-compute │ │ │ │ └── main.c │ │ │ ├── interfaces │ │ │ │ └── main.c │ │ │ ├── locks │ │ │ │ └── main.c │ │ │ ├── multi-echo-server │ │ │ │ ├── hammer.js │ │ │ │ ├── main.c │ │ │ │ └── worker.c │ │ │ ├── onchange │ │ │ │ └── main.c │ │ │ ├── pipe-echo-server │ │ │ │ └── main.c │ │ │ ├── plugin │ │ │ │ ├── hello.c │ │ │ │ ├── main.c │ │ │ │ └── plugin.h │ │ │ ├── proc-streams │ │ │ │ ├── main.c │ │ │ │ └── test.c │ │ │ ├── progress │ │ │ │ └── main.c │ │ │ ├── queue-cancel │ │ │ │ └── main.c │ │ │ ├── queue-work │ │ │ │ └── main.c │ │ │ ├── ref-timer │ │ │ │ └── main.c │ │ │ ├── signal │ │ │ │ └── main.c │ │ │ ├── spawn │ │ │ │ └── main.c │ │ │ ├── tcp-echo-server │ │ │ │ └── main.c │ │ │ ├── thread-create │ │ │ │ └── main.c │ │ │ ├── tty-gravity │ │ │ │ └── main.c │ │ │ ├── tty │ │ │ │ └── main.c │ │ │ ├── udp-dhcp │ │ │ │ └── main.c │ │ │ ├── uvcat │ │ │ │ └── main.c │ │ │ ├── uvstop │ │ │ │ └── main.c │ │ │ ├── uvtee │ │ │ │ └── main.c │ │ │ └── uvwget │ │ │ │ └── main.c │ │ ├── make.bat │ │ └── src │ │ │ ├── api.rst │ │ │ ├── async.rst │ │ │ ├── check.rst │ │ │ ├── conf.py │ │ │ ├── design.rst │ │ │ ├── dll.rst │ │ │ ├── dns.rst │ │ │ ├── errors.rst │ │ │ ├── fs.rst │ │ │ ├── fs_event.rst │ │ │ ├── fs_poll.rst │ │ │ ├── guide.rst │ │ │ ├── guide │ │ │ ├── about.rst │ │ │ ├── basics.rst │ │ │ ├── eventloops.rst │ │ │ ├── filesystem.rst │ │ │ ├── introduction.rst │ │ │ ├── networking.rst │ │ │ ├── processes.rst │ │ │ ├── threads.rst │ │ │ └── utilities.rst │ │ │ ├── handle.rst │ │ │ ├── idle.rst │ │ │ ├── index.rst │ │ │ ├── loop.rst │ │ │ ├── metrics.rst │ │ │ ├── migration_010_100.rst │ │ │ ├── misc.rst │ │ │ ├── pipe.rst │ │ │ ├── poll.rst │ │ │ ├── prepare.rst │ │ │ ├── process.rst │ │ │ ├── request.rst │ │ │ ├── signal.rst │ │ │ ├── sphinx-plugins │ │ │ └── manpage.py │ │ │ ├── static │ │ │ ├── architecture.png │ │ │ ├── diagrams.key │ │ │ │ ├── Data │ │ │ │ │ ├── st0-311.jpg │ │ │ │ │ └── st1-475.jpg │ │ │ │ ├── Index.zip │ │ │ │ ├── Metadata │ │ │ │ │ ├── BuildVersionHistory.plist │ │ │ │ │ ├── DocumentIdentifier │ │ │ │ │ └── Properties.plist │ │ │ │ ├── preview-micro.jpg │ │ │ │ ├── preview-web.jpg │ │ │ │ └── preview.jpg │ │ │ ├── favicon.ico │ │ │ ├── logo.png │ │ │ └── loop_iteration.png │ │ │ ├── stream.rst │ │ │ ├── tcp.rst │ │ │ ├── threading.rst │ │ │ ├── threadpool.rst │ │ │ ├── timer.rst │ │ │ ├── tty.rst │ │ │ ├── udp.rst │ │ │ ├── upgrading.rst │ │ │ └── version.rst │ ├── img │ │ ├── banner.png │ │ └── logos.svg │ ├── include │ │ ├── uv.h │ │ └── uv │ │ │ ├── aix.h │ │ │ ├── android-ifaddrs.h │ │ │ ├── bsd.h │ │ │ ├── darwin.h │ │ │ ├── errno.h │ │ │ ├── linux.h │ │ │ ├── os390.h │ │ │ ├── posix.h │ │ │ ├── stdint-msvc2008.h │ │ │ ├── sunos.h │ │ │ ├── threadpool.h │ │ │ ├── tree.h │ │ │ ├── unix.h │ │ │ ├── version.h │ │ │ └── win.h │ ├── libuv-static.pc.in │ ├── libuv.pc.in │ ├── m4 │ │ ├── .gitignore │ │ ├── as_case.m4 │ │ ├── ax_pthread.m4 │ │ └── libuv-check-flags.m4 │ ├── src │ │ ├── fs-poll.c │ │ ├── heap-inl.h │ │ ├── idna.c │ │ ├── idna.h │ │ ├── inet.c │ │ ├── queue.h │ │ ├── random.c │ │ ├── strscpy.c │ │ ├── strscpy.h │ │ ├── threadpool.c │ │ ├── timer.c │ │ ├── unix │ │ │ ├── aix-common.c │ │ │ ├── aix.c │ │ │ ├── android-ifaddrs.c │ │ │ ├── async.c │ │ │ ├── atomic-ops.h │ │ │ ├── bsd-ifaddrs.c │ │ │ ├── bsd-proctitle.c │ │ │ ├── core.c │ │ │ ├── cygwin.c │ │ │ ├── darwin-proctitle.c │ │ │ ├── darwin-stub.h │ │ │ ├── darwin.c │ │ │ ├── dl.c │ │ │ ├── freebsd.c │ │ │ ├── fs.c │ │ │ ├── fsevents.c │ │ │ ├── getaddrinfo.c │ │ │ ├── getnameinfo.c │ │ │ ├── haiku.c │ │ │ ├── ibmi.c │ │ │ ├── internal.h │ │ │ ├── kqueue.c │ │ │ ├── linux-core.c │ │ │ ├── linux-inotify.c │ │ │ ├── linux-syscalls.c │ │ │ ├── linux-syscalls.h │ │ │ ├── loop-watcher.c │ │ │ ├── loop.c │ │ │ ├── netbsd.c │ │ │ ├── no-fsevents.c │ │ │ ├── no-proctitle.c │ │ │ ├── openbsd.c │ │ │ ├── os390-syscalls.c │ │ │ ├── os390-syscalls.h │ │ │ ├── os390.c │ │ │ ├── pipe.c │ │ │ ├── poll.c │ │ │ ├── posix-hrtime.c │ │ │ ├── posix-poll.c │ │ │ ├── process.c │ │ │ ├── procfs-exepath.c │ │ │ ├── proctitle.c │ │ │ ├── pthread-fixes.c │ │ │ ├── qnx.c │ │ │ ├── random-devurandom.c │ │ │ ├── random-getentropy.c │ │ │ ├── random-getrandom.c │ │ │ ├── random-sysctl-linux.c │ │ │ ├── signal.c │ │ │ ├── spinlock.h │ │ │ ├── stream.c │ │ │ ├── sunos.c │ │ │ ├── sysinfo-loadavg.c │ │ │ ├── sysinfo-memory.c │ │ │ ├── tcp.c │ │ │ ├── thread.c │ │ │ ├── tty.c │ │ │ └── udp.c │ │ ├── uv-common.c │ │ ├── uv-common.h │ │ ├── uv-data-getter-setters.c │ │ ├── version.c │ │ └── win │ │ │ ├── async.c │ │ │ ├── atomicops-inl.h │ │ │ ├── core.c │ │ │ ├── detect-wakeup.c │ │ │ ├── dl.c │ │ │ ├── error.c │ │ │ ├── fs-event.c │ │ │ ├── fs-fd-hash-inl.h │ │ │ ├── fs.c │ │ │ ├── getaddrinfo.c │ │ │ ├── getnameinfo.c │ │ │ ├── handle-inl.h │ │ │ ├── handle.c │ │ │ ├── internal.h │ │ │ ├── loop-watcher.c │ │ │ ├── pipe.c │ │ │ ├── poll.c │ │ │ ├── process-stdio.c │ │ │ ├── process.c │ │ │ ├── req-inl.h │ │ │ ├── signal.c │ │ │ ├── snprintf.c │ │ │ ├── stream-inl.h │ │ │ ├── stream.c │ │ │ ├── tcp.c │ │ │ ├── thread.c │ │ │ ├── tty.c │ │ │ ├── udp.c │ │ │ ├── util.c │ │ │ ├── winapi.c │ │ │ ├── winapi.h │ │ │ ├── winsock.c │ │ │ └── winsock.h │ ├── test │ │ ├── benchmark-async-pummel.c │ │ ├── benchmark-async.c │ │ ├── benchmark-fs-stat.c │ │ ├── benchmark-getaddrinfo.c │ │ ├── benchmark-list.h │ │ ├── benchmark-loop-count.c │ │ ├── benchmark-million-async.c │ │ ├── benchmark-million-timers.c │ │ ├── benchmark-multi-accept.c │ │ ├── benchmark-ping-pongs.c │ │ ├── benchmark-ping-udp.c │ │ ├── benchmark-pound.c │ │ ├── benchmark-pump.c │ │ ├── benchmark-sizes.c │ │ ├── benchmark-spawn.c │ │ ├── benchmark-tcp-write-batch.c │ │ ├── benchmark-thread.c │ │ ├── benchmark-udp-pummel.c │ │ ├── blackhole-server.c │ │ ├── dns-server.c │ │ ├── echo-server.c │ │ ├── fixtures │ │ │ ├── empty_file │ │ │ ├── load_error.node │ │ │ └── lorem_ipsum.txt │ │ ├── run-benchmarks.c │ │ ├── run-tests.c │ │ ├── runner-unix.c │ │ ├── runner-unix.h │ │ ├── runner-win.c │ │ ├── runner-win.h │ │ ├── runner.c │ │ ├── runner.h │ │ ├── task.h │ │ ├── test-active.c │ │ ├── test-async-null-cb.c │ │ ├── test-async.c │ │ ├── test-barrier.c │ │ ├── test-callback-order.c │ │ ├── test-callback-stack.c │ │ ├── test-close-fd.c │ │ ├── test-close-order.c │ │ ├── test-condvar.c │ │ ├── test-connect-unspecified.c │ │ ├── test-connection-fail.c │ │ ├── test-cwd-and-chdir.c │ │ ├── test-default-loop-close.c │ │ ├── test-delayed-accept.c │ │ ├── test-dlerror.c │ │ ├── test-eintr-handling.c │ │ ├── test-embed.c │ │ ├── test-emfile.c │ │ ├── test-env-vars.c │ │ ├── test-error.c │ │ ├── test-fail-always.c │ │ ├── test-fork.c │ │ ├── test-fs-copyfile.c │ │ ├── test-fs-event.c │ │ ├── test-fs-fd-hash.c │ │ ├── test-fs-open-flags.c │ │ ├── test-fs-poll.c │ │ ├── test-fs-readdir.c │ │ ├── test-fs.c │ │ ├── test-get-currentexe.c │ │ ├── test-get-loadavg.c │ │ ├── test-get-memory.c │ │ ├── test-get-passwd.c │ │ ├── test-getaddrinfo.c │ │ ├── test-gethostname.c │ │ ├── test-getnameinfo.c │ │ ├── test-getsockname.c │ │ ├── test-getters-setters.c │ │ ├── test-gettimeofday.c │ │ ├── test-handle-fileno.c │ │ ├── test-homedir.c │ │ ├── test-hrtime.c │ │ ├── test-idle.c │ │ ├── test-idna.c │ │ ├── test-ip4-addr.c │ │ ├── test-ip6-addr.c │ │ ├── test-ipc-heavy-traffic-deadlock-bug.c │ │ ├── test-ipc-send-recv.c │ │ ├── test-ipc.c │ │ ├── test-list.h │ │ ├── test-loop-alive.c │ │ ├── test-loop-close.c │ │ ├── test-loop-configure.c │ │ ├── test-loop-handles.c │ │ ├── test-loop-stop.c │ │ ├── test-loop-time.c │ │ ├── test-metrics.c │ │ ├── test-multiple-listen.c │ │ ├── test-mutexes.c │ │ ├── test-osx-select.c │ │ ├── test-pass-always.c │ │ ├── test-ping-pong.c │ │ ├── test-pipe-bind-error.c │ │ ├── test-pipe-close-stdout-read-stdin.c │ │ ├── test-pipe-connect-error.c │ │ ├── test-pipe-connect-multiple.c │ │ ├── test-pipe-connect-prepare.c │ │ ├── test-pipe-getsockname.c │ │ ├── test-pipe-pending-instances.c │ │ ├── test-pipe-sendmsg.c │ │ ├── test-pipe-server-close.c │ │ ├── test-pipe-set-fchmod.c │ │ ├── test-pipe-set-non-blocking.c │ │ ├── test-platform-output.c │ │ ├── test-poll-close-doesnt-corrupt-stack.c │ │ ├── test-poll-close.c │ │ ├── test-poll-closesocket.c │ │ ├── test-poll-multiple-handles.c │ │ ├── test-poll-oob.c │ │ ├── test-poll.c │ │ ├── test-process-priority.c │ │ ├── test-process-title-threadsafe.c │ │ ├── test-process-title.c │ │ ├── test-queue-foreach-delete.c │ │ ├── test-random.c │ │ ├── test-ref.c │ │ ├── test-run-nowait.c │ │ ├── test-run-once.c │ │ ├── test-semaphore.c │ │ ├── test-shutdown-close.c │ │ ├── test-shutdown-eof.c │ │ ├── test-shutdown-twice.c │ │ ├── test-signal-multiple-loops.c │ │ ├── test-signal-pending-on-close.c │ │ ├── test-signal.c │ │ ├── test-socket-buffer-size.c │ │ ├── test-spawn.c │ │ ├── test-stdio-over-pipes.c │ │ ├── test-strscpy.c │ │ ├── test-tcp-alloc-cb-fail.c │ │ ├── test-tcp-bind-error.c │ │ ├── test-tcp-bind6-error.c │ │ ├── test-tcp-close-accept.c │ │ ├── test-tcp-close-reset.c │ │ ├── test-tcp-close-while-connecting.c │ │ ├── test-tcp-close.c │ │ ├── test-tcp-connect-error-after-write.c │ │ ├── test-tcp-connect-error.c │ │ ├── test-tcp-connect-timeout.c │ │ ├── test-tcp-connect6-error.c │ │ ├── test-tcp-create-socket-early.c │ │ ├── test-tcp-flags.c │ │ ├── test-tcp-oob.c │ │ ├── test-tcp-open.c │ │ ├── test-tcp-read-stop-start.c │ │ ├── test-tcp-read-stop.c │ │ ├── test-tcp-shutdown-after-write.c │ │ ├── test-tcp-try-write-error.c │ │ ├── test-tcp-try-write.c │ │ ├── test-tcp-unexpected-read.c │ │ ├── test-tcp-write-after-connect.c │ │ ├── test-tcp-write-fail.c │ │ ├── test-tcp-write-queue-order.c │ │ ├── test-tcp-write-to-half-open-connection.c │ │ ├── test-tcp-writealot.c │ │ ├── test-test-macros.c │ │ ├── test-thread-equal.c │ │ ├── test-thread.c │ │ ├── test-threadpool-cancel.c │ │ ├── test-threadpool.c │ │ ├── test-timer-again.c │ │ ├── test-timer-from-check.c │ │ ├── test-timer.c │ │ ├── test-tmpdir.c │ │ ├── test-tty-duplicate-key.c │ │ ├── test-tty-escape-sequence-processing.c │ │ ├── test-tty.c │ │ ├── test-udp-alloc-cb-fail.c │ │ ├── test-udp-bind.c │ │ ├── test-udp-connect.c │ │ ├── test-udp-create-socket-early.c │ │ ├── test-udp-dgram-too-big.c │ │ ├── test-udp-ipv6.c │ │ ├── test-udp-mmsg.c │ │ ├── test-udp-multicast-interface.c │ │ ├── test-udp-multicast-interface6.c │ │ ├── test-udp-multicast-join.c │ │ ├── test-udp-multicast-join6.c │ │ ├── test-udp-multicast-ttl.c │ │ ├── test-udp-open.c │ │ ├── test-udp-options.c │ │ ├── test-udp-send-and-recv.c │ │ ├── test-udp-send-hang-loop.c │ │ ├── test-udp-send-immediate.c │ │ ├── test-udp-send-unreachable.c │ │ ├── test-udp-sendmmsg-error.c │ │ ├── test-udp-try-send.c │ │ ├── test-uname.c │ │ ├── test-walk-handles.c │ │ └── test-watcher-cross-stop.c │ ├── tools │ │ ├── make_dist_html.py │ │ └── vswhere_usability_wrapper.cmd │ └── uv_win_longpath.manifest └── llhttp │ ├── CMakeLists.txt │ ├── LICENSE-MIT │ ├── README.md │ ├── common.gypi │ ├── include │ └── llhttp.h │ ├── llhttp.gyp │ └── src │ ├── api.c │ ├── http.c │ └── llhttp.c ├── examples └── handler.js └── src └── main.c /.github/workflows/CI.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | 3 | on: [push, pull_request] 4 | 5 | jobs: 6 | test: 7 | runs-on: ${{ matrix.operating-system }} 8 | strategy: 9 | matrix: 10 | operating-system: [ubuntu-latest, windows-latest, macos-latest] 11 | steps: 12 | - uses: actions/checkout@v2 13 | - name: Environment Information 14 | run: npx envinfo 15 | - name: build 16 | run: | 17 | cmake . 18 | cmake --build . 19 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | -------------------------------------------------------------------------------- /deps/duktape/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.4) 2 | project(duktape LANGUAGES C) 3 | 4 | add_library(duktape src/duktape.c) 5 | 6 | target_include_directories(duktape PUBLIC "${PROJECT_SOURCE_DIR}/src") 7 | -------------------------------------------------------------------------------- /deps/duktape/Makefile.codepage: -------------------------------------------------------------------------------- 1 | CC = gcc 2 | 3 | codepage: 4 | $(CC) -o $@ -std=c99 -O2 -Wall -Wextra -Isrc/ \ 5 | src/duktape.c examples/codepage-conv/duk_codepage_conv.c \ 6 | examples/codepage-conv/test.c -lm 7 | -------------------------------------------------------------------------------- /deps/duktape/Makefile.coffee: -------------------------------------------------------------------------------- 1 | dummy: 2 | coffee -c examples/coffee/globals.coffee 3 | coffee -c examples/coffee/hello.coffee 4 | coffee -c examples/coffee/mandel.coffee 5 | -------------------------------------------------------------------------------- /deps/duktape/Makefile.eval: -------------------------------------------------------------------------------- 1 | # 2 | # Example Makefile for building the eval example 3 | # 4 | 5 | CC = gcc 6 | 7 | eval: 8 | $(CC) -o $@ -std=c99 -O2 -Wall -Wextra -Isrc/ \ 9 | src/duktape.c examples/eval/eval.c -lm 10 | -------------------------------------------------------------------------------- /deps/duktape/Makefile.jsoncbor: -------------------------------------------------------------------------------- 1 | # 2 | # Example Makefile for building the jsoncbor example 3 | # 4 | 5 | CC = gcc 6 | 7 | jsoncbor: 8 | $(CC) -o $@ -std=c99 -Wall -Wextra -O2 -Isrc -Iextras/cbor \ 9 | src/duktape.c extras/cbor/duk_cbor.c extras/cbor/jsoncbor.c \ 10 | -lm 11 | -------------------------------------------------------------------------------- /deps/duktape/Makefile.jxpretty: -------------------------------------------------------------------------------- 1 | # 2 | # Example Makefile for building the jxpretty example 3 | # 4 | 5 | CC = gcc 6 | 7 | jxpretty: 8 | $(CC) -o $@ -std=c99 -Wall -Wextra -O2 -Isrc \ 9 | src/duktape.c examples/jxpretty/jxpretty.c \ 10 | -lm 11 | -------------------------------------------------------------------------------- /deps/duktape/Makefile.sandbox: -------------------------------------------------------------------------------- 1 | # 2 | # Example Makefile for building the sandbox example 3 | # 4 | 5 | CC = gcc 6 | 7 | sandbox: 8 | $(CC) -o $@ -std=c99 -O2 -Wall -Wextra -Isrc/ \ 9 | src/duktape.c examples/sandbox/sandbox.c -lm 10 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_arm32.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "arm32" 2 | /* Byte order varies, so rely on autodetect. */ 3 | #define DUK_USE_PACKED_TVAL 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_arm64.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "arm64" 2 | /* Byte order varies, so rely on autodetect. */ 3 | #undef DUK_USE_PACKED_TVAL 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_emscripten.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "emscripten" 2 | #if !defined(DUK_USE_BYTEORDER) 3 | #define DUK_USE_BYTEORDER 1 4 | #endif 5 | #undef DUK_USE_PACKED_TVAL 6 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_generic.h.in: -------------------------------------------------------------------------------- 1 | /* These are necessary wild guesses. */ 2 | #define DUK_USE_ARCH_STRING "generic" 3 | /* Rely on autodetection for byte order, alignment, and packed tval. */ 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_m68k.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "m68k" 2 | #if !defined(DUK_USE_BYTEORDER) 3 | #define DUK_USE_BYTEORDER 3 4 | #endif 5 | #define DUK_USE_PACKED_TVAL 6 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_mips32.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "mips32" 2 | /* MIPS byte order varies so rely on autodetection. */ 3 | #define DUK_USE_PACKED_TVAL 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_mips64.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "mips64" 2 | /* MIPS byte order varies so rely on autodetection. */ 3 | #undef DUK_USE_PACKED_TVAL 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_powerpc32.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "ppc32" 2 | #if !defined(DUK_USE_BYTEORDER) 3 | #define DUK_USE_BYTEORDER 3 4 | #endif 5 | #define DUK_USE_PACKED_TVAL 6 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_powerpc64.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "ppc64" 2 | /* No forced byteorder (both little and big endian are possible). */ 3 | #undef DUK_USE_PACKED_TVAL 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_riscv32.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "riscv32" 2 | #define DUK_USE_BYTEORDER 1 3 | #define DUK_USE_PACKED_TVAL 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_riscv64.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "riscv64" 2 | #define DUK_USE_BYTEORDER 1 3 | #undef DUK_USE_PACKED_TVAL 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_sparc32.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "sparc32" 2 | /* SPARC byte order varies so rely on autodetection. */ 3 | #define DUK_USE_PACKED_TVAL 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_sparc64.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "sparc64" 2 | /* SPARC byte order varies so rely on autodetection. */ 3 | #undef DUK_USE_PACKED_TVAL 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_superh.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "sh" 2 | /* Byte order varies, rely on autodetection. */ 3 | #define DUK_USE_PACKED_TVAL 4 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_x32.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "x32" 2 | #if !defined(DUK_USE_BYTEORDER) 3 | #define DUK_USE_BYTEORDER 1 4 | #endif 5 | #define DUK_USE_PACKED_TVAL 6 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_x64.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "x64" 2 | #if !defined(DUK_USE_BYTEORDER) 3 | #define DUK_USE_BYTEORDER 1 4 | #endif 5 | #undef DUK_USE_PACKED_TVAL 6 | -------------------------------------------------------------------------------- /deps/duktape/config/architectures/architecture_x86.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_ARCH_STRING "x86" 2 | #if !defined(DUK_USE_BYTEORDER) 3 | #define DUK_USE_BYTEORDER 1 4 | #endif 5 | 6 | #define DUK_USE_PACKED_TVAL 7 | 8 | /* FreeBSD, -m32, and clang prior to 5.0 has union aliasing issues which 9 | * break duk_tval copying. Disable packed duk_tval automatically. 10 | */ 11 | #if defined(DUK_F_FREEBSD) && defined(DUK_F_X86) && \ 12 | defined(__clang__) && defined(__clang_major__) && (__clang_major__ < 5) 13 | #undef DUK_USE_PACKED_TVAL 14 | #endif 15 | -------------------------------------------------------------------------------- /deps/duktape/config/compilers/compiler_tinyc.h.in: -------------------------------------------------------------------------------- 1 | #undef DUK_USE_BRANCH_HINTS 2 | 3 | #if defined(DUK_F_CPP) 4 | #define DUK_USE_COMPILER_STRING "tinyc++" 5 | #else 6 | #define DUK_USE_COMPILER_STRING "tinyc" 7 | #endif 8 | 9 | /* http://bellard.org/tcc/tcc-doc.html#SEC7 */ 10 | #define DUK_USE_VARIADIC_MACROS 11 | 12 | #define DUK_USE_UNION_INITIALIZERS 13 | 14 | /* Most portable, wastes space */ 15 | #define DUK_USE_FLEX_ONESIZE 16 | 17 | /* Most portable, potentially wastes space */ 18 | #define DUK_USE_PACK_DUMMY_MEMBER 19 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_32BIT_PTRS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_32BIT_PTRS 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Pointers are 32-bit integer compatible. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_64BIT_OPS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_64BIT_OPS 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - portability 6 | description: > 7 | Use 64-bit integer operations. On some platforms 64-bit types may be 8 | available but 64-bit operations don't work correctly e.g. in integer/float 9 | casts. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ALIGN_4.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ALIGN_4 2 | introduced: 1.0.0 3 | removed: 1.3.0 4 | related: 5 | - DUK_USE_ALIGN_BY 6 | default: false 7 | tags: 8 | - portability 9 | description: > 10 | Use 4-byte alignment for 64-bit integers and IEEE doubles. 11 | Replaced by DUK_USE_ALIGN_BY. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ALIGN_8.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ALIGN_8 2 | introduced: 1.0.0 3 | removed: 1.3.0 4 | related: 5 | - DUK_USE_ALIGN_BY 6 | default: false 7 | tags: 8 | - portability 9 | description: > 10 | Use 8-byte alignment for 64-bit integers and IEEE doubles. 11 | Replaced by DUK_USE_ALIGN_BY. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ALIGN_BY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ALIGN_BY 2 | introduced: 1.3.0 3 | default: 8 4 | tags: 5 | - portability 6 | description: > 7 | Use N-byte alignment for 64-bit integers and IEEE doubles 8 | (supported values are 1, 4, and 8). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ALLOW_UNDEFINED_BEHAVIOR.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ALLOW_UNDEFINED_BEHAVIOR 2 | introduced: 2.3.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Allow technically undefined behavior such as out-of-range double-to-integer 8 | casts, floating point division by zero, etc. which are likely to work on the 9 | majority of platforms. Default is to avoid such behaviors, at the cost of 10 | some footprint and performance. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ARCH_STRING.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ARCH_STRING 2 | introduced: 1.0.0 3 | default: 4 | string: "unknown" 5 | tags: 6 | - portability 7 | description: > 8 | Human-readable architecture string used in e.g. Duktape.env and debugger 9 | protocol (example: x64). 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ARRAY_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ARRAY_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide an Array built-in. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ASSERTIONS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ASSERTIONS 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - development 6 | - debug 7 | description: > 8 | Enable internal assert checks. These slow down execution considerably 9 | so only use when debugging. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ATAN2_WORKAROUNDS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ATAN2_WORKAROUNDS 2 | introduced: 2.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Enable workarounds to common atan2() semantics issues. At least Cygwin/MinGW 8 | has such issues, see test-bug-mingw-math-issues.js. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_AUGMENT_ERROR_CREATE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_AUGMENT_ERROR_CREATE 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Augment an ECMAScript error object at creation with tracedata or 8 | fileName/lineNumber, or Duktape.errCreate (if enabled). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_AUGMENT_ERROR_THROW.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_AUGMENT_ERROR_THROW 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Augment an ECMAScript error object at throw time with Duktape.errThrow 8 | (if enabled). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_BASE64_FASTPATH.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_BASE64_FASTPATH 2 | introduced: 1.4.0 3 | default: true 4 | tags: 5 | - performance 6 | - fastpath 7 | - lowmemory 8 | description: > 9 | Enable fast path for base64 encode/decode. The fast path uses a lookup 10 | table at a small cost in footprint. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_BASE64_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_BASE64_SUPPORT 2 | introduced: 2.3.0 3 | default: true 4 | tags: 5 | - codec 6 | description: > 7 | Enable base64 encoding/decoding support. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_BOOLEAN_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_BOOLEAN_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide a Boolean built-in. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_BRANCH_HINTS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_BRANCH_HINTS 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - portability 6 | description: > 7 | Use branch hints if the compiler supports them. 8 | 9 | # XXX: Unused now, DUK_LIKELY and DUK_UNLIKELY are used instead. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_BROWSER_LIKE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_BROWSER_LIKE 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: true 5 | tags: 6 | - ecmascript 7 | description: > 8 | Provide browser-like bindings: currently print() and alert(). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_BUFLEN16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_BUFLEN16 2 | introduced: 1.1.0 3 | default: false 4 | tags: 5 | - lowmemory 6 | - experimental 7 | description: > 8 | Use a 16-bit buffer length field (for low memory environments). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_BUILTIN_INITJS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_BUILTIN_INITJS 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: true 5 | tags: 6 | - ecmascript 7 | description: > 8 | Use built-in .js init code when creating a new global context. 9 | The .js init code (duk_initjs.js) provides some initialization 10 | code that's nicer to implement in ECMAScript, and is also used 11 | to provide some backwards compatibility bindings which are easy 12 | to remove later. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_BYTECODE_DUMP_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_BYTECODE_DUMP_SUPPORT 2 | introduced: 1.3.0 3 | default: true 4 | tags: 5 | - api 6 | description: > 7 | Enable support for API calls to dump/load function bytecode. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_BYTEORDER_FORCED.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_BYTEORDER_FORCED 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Byte order was forced (instead of being autodetected). This has no 9 | functional impact but the forced status shows up in Duktape.env. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_CACHE_ACTIVATION.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_CACHE_ACTIVATION 2 | introduced: 2.2.0 3 | default: true 4 | tags: 5 | - performance 6 | description: > 7 | Cache duk_activation records. When releasing a duk_activation, place it in 8 | a free list for later reuse. Mark-and-sweep frees the free list to keep 9 | memory usage in check. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_CACHE_CATCHER.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_CACHE_CATCHER 2 | introduced: 2.2.0 3 | default: true 4 | tags: 5 | - performance 6 | description: > 7 | Cache duk_catcher records. When releasing a duk_catcher, place it in 8 | a free list for later reuse. Mark-and-sweep frees the free list to keep 9 | memory usage in check. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_CALLSTACK_LIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_CALLSTACK_LIMIT 2 | introduced: 2.2.0 3 | default: 10000 4 | tags: 5 | - misc 6 | description: > 7 | Maximum call stack size. If call stack would grow beyond this value, reject 8 | the call in progress. This mainly protects against runaway recursion. Note 9 | in particular that this limit is unrelated to the native C stack size which 10 | has a separate limit define. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_CBOR_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_CBOR_BUILTIN 2 | introduced: 2.5.0 3 | default: true 4 | tags: 5 | - codec 6 | - cbor 7 | - experimental 8 | description: > 9 | Provide a CBOR built-in with CBOR.encode() and CBOR.decode() functions. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_CBOR_DEC_RECLIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_CBOR_DEC_RECLIMIT 2 | introduced: 2.6.0 3 | default: 1000 4 | tags: 5 | - portability 6 | - cstackdepth 7 | description: > 8 | Maximum native stack recursion for CBOR decoding. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_CBOR_ENC_RECLIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_CBOR_ENC_RECLIMIT 2 | introduced: 2.6.0 3 | default: 1000 4 | tags: 5 | - portability 6 | - cstackdepth 7 | description: > 8 | Maximum native stack recursion for CBOR encoding. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_CBOR_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_CBOR_SUPPORT 2 | introduced: 2.5.0 3 | default: true 4 | tags: 5 | - codec 6 | - cbor 7 | - experimental 8 | description: > 9 | Include CBOR support. When disabled, CBOR functions in the C API (and the 10 | CBOR built-in, if enabled) will throw an error. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_CLANG_PRAGMAS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_CLANG_PRAGMAS 2 | introduced: 2.5.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use Clang-specific pragmas, e.g. "#pragma clang diagnostic" to suppress 8 | unnecessary warnings. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_COMMONJS_MODULES.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_COMMONJS_MODULES 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: true 5 | tags: 6 | - ecmascript 7 | description: > 8 | Enable support for CommonJS modules. When enabled, the global require() 9 | function provides a simple module loader facility which depends on the user 10 | providing low level module searching functionality. When disabled, the 11 | global require() function is present but throws an error. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_COMPILER_RECLIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_COMPILER_RECLIMIT 2 | introduced: 1.3.0 3 | default: 2500 4 | tags: 5 | - portability 6 | - cstackdepth 7 | description: > 8 | ECMAScript compiler native call stack recursion limit. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_COMPILER_STRING.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_COMPILER_STRING 2 | introduced: 1.0.0 3 | default: 4 | string: "unknown" 5 | tags: 6 | - portability 7 | description: > 8 | Human-readable compiler string used in e.g. Duktape.env and debugger 9 | protocol (example: gcc). 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_COROUTINE_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_COROUTINE_SUPPORT 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - execution 6 | description: > 7 | Enable support for Duktape coroutines, i.e. yield/resume. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_CPP_EXCEPTIONS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_CPP_EXCEPTIONS 2 | introduced: 1.4.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use C++ exceptions instead of setjmp/longjmp for long control transfers. 8 | This allows Duktape/C functions written in C++ to use automatic destructors 9 | (RAII or scope-based resource management). 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATAPTR_DEC16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATAPTR_DEC16 2 | introduced: 1.1.0 3 | requires: 4 | - DUK_USE_DATAPTR16 5 | default: false 6 | tags: 7 | - lowmemory 8 | - experimental 9 | description: > 10 | Use together with DUK_USE_DATAPTR16 for arbitrary data pointer compression. 11 | DUK_USE_DATAPTR_DEC16(udata,x) is a macro with a userdata and duk_uint16_t 12 | argument, and a void ptr return value. The userdata argument is the heap 13 | userdata value given at heap creation. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide a Date built-in. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_FMT_STRFTIME.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_FMT_STRFTIME 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use strftime() to format Date values in native, platform specific format 9 | before falling back into ISO 8601. When enabled, appropriate date/time 10 | headers must be included. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_FORMAT_STRING.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_FORMAT_STRING 2 | introduced: 1.3.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Optional macro for formatting a date in a platform dependent manner, 9 | see datetime.rst. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_GET_LOCAL_TZOFFSET.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_GET_LOCAL_TZOFFSET 2 | introduced: 1.3.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Mandatory macro for getting the local time offset for a given datetime, 9 | see datetime.rst. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_NOW_GETTIMEOFDAY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_NOW_GETTIMEOFDAY 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use gettimeofday() to get current datetime. When enabled, appropriate 9 | date/time headers must be included. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_NOW_TIME.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_NOW_TIME 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use time() to get current datetime, with the limitation that datetime is 9 | limited to one second resolution. When enabled, appropriate date/time 10 | headers must be included. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_NOW_WINDOWS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_NOW_WINDOWS 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use Win32 API calls to get current datetime. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_NOW_WINDOWS_SUBMS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_NOW_WINDOWS_SUBMS 2 | introduced: 2.2.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Like DUK_USE_DATE_NOW_WINDOWS but use GetSystemTimePreciseAsFileTime(), 9 | available since Windows 8, for sub-millisecond resolution. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_PARSE_STRING.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_PARSE_STRING 2 | introduced: 1.3.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Optional macro for parsing a date in a platform dependent manner, 9 | see datetime.rst. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_PRS_GETDATE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_PRS_GETDATE 2 | introduced: 1.3.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use getdate_r() to parse a platform specific datetime string into ECMAScript 9 | time. getdate_r() depends on DATEMSK being set so this is not always very 10 | convenient for an embedded interpreter. When enabled, appropriate date/time 11 | headers must be included. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_PRS_STRPTIME.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_PRS_STRPTIME 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use strptime() to parse a platform specific datetime string into ECMAScript 9 | time. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_TZO_GMTIME.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_TZO_GMTIME 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use gmtime() to get local time offset at a certain time. 9 | When enabled, appropriate date/time headers must be included. 10 | 11 | Since gmtime() is not re-entrant, this is not thread safe. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_TZO_GMTIME_R.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_TZO_GMTIME_R 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use gmtime_r() to get local time offset at a certain time. 9 | When enabled, appropriate date/time headers must be included. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_TZO_GMTIME_S.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_TZO_GMTIME_S 2 | introduced: 2.0.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use gmtime_s() to get local time offset at a certain time. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_TZO_WINDOWS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_TZO_WINDOWS 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use Win32 API calls to get local time offset at a certain time. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DATE_TZO_WINDOWS_NO_DST.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DATE_TZO_WINDOWS_NO_DST 2 | introduced: 2.0.1 3 | default: false 4 | tags: 5 | - date 6 | - portability 7 | description: > 8 | Use Win32 API calls to get local time offset at a certain time. 9 | Does not take into account daylight savings time. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DDDPRINT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DDDPRINT 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: false 5 | tags: 6 | - debug 7 | description: > 8 | Enable even more debug printouts. Not recommended unless you have 9 | grep handy. Replaced by DUK_USE_DEBUG_LEVEL. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DDPRINT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DDPRINT 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: false 5 | tags: 6 | - debug 7 | description: > 8 | Enable more debug printouts. Replaced by DUK_USE_DEBUG_LEVEL. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DEBUG.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DEBUG 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - debug 6 | description: > 7 | Enable debug code in Duktape internals. Without this option other 8 | debugging options (such as DUK_USE_DEBUG_LEVEL and DUK_USE_DEBUG_WRITE) 9 | have no effect. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DEBUGGER_DUMPHEAP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DEBUGGER_DUMPHEAP 2 | introduced: 1.2.0 3 | # Option is ignored unless debugger support is enabled. 4 | #requires: 5 | # - DUK_USE_DEBUGGER_SUPPORT 6 | default: false 7 | tags: 8 | - debugger 9 | description: > 10 | Support the DumpHeap command. This is optional because the command is not 11 | always needed. The command also has a relatively large footprint (about 12 | 10% of debugger code); in absolute terms it's about 1kB of code footprint. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DEBUGGER_FWD_PRINTALERT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DEBUGGER_FWD_PRINTALERT 2 | introduced: 1.2.0 3 | removed: 2.0.0 4 | # Option is ignored unless debugger support is enabled. 5 | #requires: 6 | # - DUK_USE_DEBUGGER_SUPPORT 7 | default: false 8 | tags: 9 | - debugger 10 | description: > 11 | Forward calls to the built-in print() and alert() function to the debug 12 | client. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DEBUGGER_INSPECT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DEBUGGER_INSPECT 2 | introduced: 1.5.0 3 | # Option is ignored unless debugger support is enabled. 4 | #requires: 5 | # - DUK_USE_DEBUGGER_SUPPORT 6 | default: false 7 | tags: 8 | - debugger 9 | description: > 10 | Support debugger heap object inspection commands GetHeapObjInfo, 11 | GetObjPropDesc, GetObjPropDescRange. These are optional because the 12 | commands have a relatively high code footprint (about 3kB) and are not 13 | always needed. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DEBUGGER_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DEBUGGER_SUPPORT 2 | introduced: 1.2.0 3 | requires: 4 | - DUK_USE_INTERRUPT_COUNTER 5 | default: false 6 | tags: 7 | - debugger 8 | description: > 9 | Enable support for Duktape debug protocol (see doc/debugger.rst) and the 10 | debug API calls (duk_debugger_attach(), duk_debugger_detach(), etc). 11 | This adds about 10kB of code footprint at the moment. 12 | 13 | This option requires DUK_USE_INTERRUPT_COUNTER. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DEBUGGER_THROW_NOTIFY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DEBUGGER_THROW_NOTIFY 2 | introduced: 1.4.0 3 | # Option is ignored unless debugger support is enabled. 4 | #requires: 5 | # - DUK_USE_DEBUGGER_SUPPORT 6 | related: 7 | - DUK_USE_DEBUGGER_PAUSE_UNCAUGHT 8 | default: true 9 | tags: 10 | - debugger 11 | description: > 12 | Send a Throw notify when an error is about to be thrown. The Throw notify 13 | also indicates if an error is fatal (most likely not caught) which is very 14 | useful in debugging. 15 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DEBUG_LEVEL.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DEBUG_LEVEL 2 | introduced: 2.0.0 3 | default: 0 4 | tags: 5 | - debug 6 | description: > 7 | Set debug print level when DUK_USE_DEBUG is enabled. The level can be 8 | 0 (minimal), 1 (verbose), 2 (very verbose). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DEEP_C_STACK.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DEEP_C_STACK 2 | introduced: 1.0.0 3 | removed: 1.3.0 4 | default: true 5 | tags: 6 | - portability 7 | description: > 8 | Assume deep C stacks are not an issue on the target platform; on some 9 | embedded platforms the native C stack is very limited (e.g. 32-64 kB) 10 | and overrunning the stack leads to difficult-to-diagnose problems. 11 | 12 | Removed in Duktape 1.3.0, replaced by explicit recursion limits. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DOUBLE_BE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DOUBLE_BE 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: false 5 | conflicts: 6 | - DUK_USE_DOUBLE_LE 7 | - DUK_USE_DOUBLE_ME 8 | tags: 9 | - portability 10 | description: > 11 | IEEE double memory representation is big endian on the target platform. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DOUBLE_LE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DOUBLE_LE 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: true 5 | conflicts: 6 | - DUK_USE_DOUBLE_BE 7 | - DUK_USE_DOUBLE_ME 8 | tags: 9 | - portability 10 | description: > 11 | IEEE double memory representation is little endian on the target platform. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DOUBLE_LINKED_HEAP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DOUBLE_LINKED_HEAP 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Use a double-linked duk_heaphdr structure. Required when reference 8 | counting is enabled. 9 | 10 | # XXX: This must currently always match DUK_USE_REFERENCE_COUNTING 11 | # so remove as a separate option? 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DOUBLE_ME.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DOUBLE_ME 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: false 5 | conflicts: 6 | - DUK_USE_DOUBLE_LE 7 | - DUK_USE_DOUBLE_BE 8 | tags: 9 | - portability 10 | description: > 11 | IEEE double memory representation is mixed endian on the target platform. 12 | In other words the logical bytes ABCDEFGH are represented in memory as 13 | DCBAHGFE. This endianness is used by some ARM platforms. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DPRINT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DPRINT 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | requires: 5 | - DUK_USE_DEBUG 6 | default: false 7 | tags: 8 | - debug 9 | description: > 10 | Enable debug printouts. Replaced by DUK_USE_DEBUG_LEVEL. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DPRINT_COLORS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DPRINT_COLORS 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: false 5 | tags: 6 | - debug 7 | description: > 8 | Enable coloring of debug prints with ANSI escape codes 9 | (http://en.wikipedia.org/wiki/ANSI_escape_code). The behavior is not 10 | sensitive to terminal settings. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DPRINT_RDTSC.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DPRINT_RDTSC 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: false 5 | tags: 6 | - debug 7 | description: > 8 | Print RDTSC cycle count in debug prints if available. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_DUKTAPE_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_DUKTAPE_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - duktape 6 | description: > 7 | Provide a Duktape built-in. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ERRCREATE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ERRCREATE 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Call Duktape.errCreate() when augmenting an ECMAScript error object 8 | being created. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ERRTHROW.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ERRTHROW 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Call Duktape.errThrow() when augmenting an ECMAScript error object 8 | about to be thrown. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ES6.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ES6 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript2015 6 | description: > 7 | Enable ES6 functionality not covered by other specific config options. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ES6_OBJECT_PROTO_PROPERTY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ES6_OBJECT_PROTO_PROPERTY 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript2015 6 | description: > 7 | Provide the non-standard (ES6) Object.prototype.__proto__ property. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ES6_OBJECT_SETPROTOTYPEOF.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ES6_OBJECT_SETPROTOTYPEOF 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript2015 6 | description: > 7 | Provide the non-standard (ES6) Object.setPrototypeOf method. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ES6_PROXY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ES6_PROXY 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript2015 6 | description: > 7 | Provide the non-standard (ES6) Proxy object. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ES6_REGEXP_BRACES.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ES6_REGEXP_BRACES 2 | introduced: 1.5.0 3 | removed: 2.0.0 4 | default: true 5 | tags: 6 | - ecmascript2015 7 | description: > 8 | Replaced by DUK_USE_ES6_REGEXP_SYNTAX. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ES6_UNICODE_ESCAPE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ES6_UNICODE_ESCAPE 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript2015 6 | description: > 7 | Enable support for ES6 Unicode escape syntax ("\u{12345}") in source code 8 | and RegExps. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ES7.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ES7 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript2016 6 | description: > 7 | Enable ES7 functionality not covered by other specific config options. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ES7_EXP_OPERATOR.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ES7_EXP_OPERATOR 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript2016 6 | description: > 7 | Support the ES7 exponentiation operator (** and **=). This is optional 8 | because the operator pulls in pow() which may have a significant footprint 9 | impact on bare metal platforms. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ES8.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ES8 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript2017 6 | description: > 7 | Enable ES8 functionality not covered by other specific config options. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ES9.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ES9 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript2018 6 | description: > 7 | Enable ES9 functionality not covered by other specific config options. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ESBC_LIMITS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ESBC_LIMITS 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Impose byte and line number limits for compiled function bytecode. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ESBC_MAX_BYTES.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ESBC_MAX_BYTES 2 | introduced: 1.0.0 3 | requires: 4 | - DUK_USE_ESBC_LIMITS 5 | default: 0x7fff0000 6 | tags: 7 | - ecmascript 8 | description: > 9 | Maximum byte count for compiled function bytecode. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ESBC_MAX_LINENUMBER.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ESBC_MAX_LINENUMBER 2 | introduced: 1.0.0 3 | requires: 4 | - DUK_USE_ESBC_LIMITS 5 | default: 0x7fff0000 6 | tags: 7 | - ecmascript 8 | description: > 9 | Maximum line number for compiled function bytecode. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_EXEC_INDIRECT_BOUND_CHECK.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_EXEC_INDIRECT_BOUND_CHECK 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - execution 6 | - debug 7 | description: > 8 | For opcodes with indirect indices, check final index against stack size. 9 | Useful for diagnosing problems. Normally this check is not necessary 10 | because the compiler is trusted, and we don't bound check direct indices 11 | either. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_EXEC_PREFER_SIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_EXEC_PREFER_SIZE 2 | introduced: 2.0.0 3 | default: false 4 | tags: 5 | - lowmemory 6 | description: > 7 | Prefer size over performance in bytecode executor. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_EXEC_REGCONST_OPTIMIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_EXEC_REGCONST_OPTIMIZE 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - performance 6 | - execution 7 | description: > 8 | Use an internal optimization to access registers and constants in the 9 | bytecode executor. The optimization avoids unnecessary shifts when computing 10 | addresses but assumes sizeof(duk_tval) is 8 or 16. This is almost always the 11 | case, but when it isn't, disable this option. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_EXPLICIT_NULL_INIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_EXPLICIT_NULL_INIT 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | When zeroing structures, don't rely on memzero initializing pointers to 8 | NULL. Instead, write NULL values explicitly after zeroing. This should 9 | only be necessary when a NULL pointer is not represented by zero bytes in 10 | memory. 11 | 12 | # NOTE: Condition in Duktape 1.2 seems wrong, and is linked to packed tval. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FAST_REFCOUNT_DEFAULT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FAST_REFCOUNT_DEFAULT 2 | introduced: 1.2.0 3 | default: true 4 | tags: 5 | - performance 6 | - fastpath 7 | - experimental 8 | description: > 9 | When enabled, plain refcount macros (e.g. DUK_TVAL_INCREF) default to 10 | fast variants (DUK_TVAL_INCREF_FAST) to improve performance. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FATAL_MAXLEN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FATAL_MAXLEN 2 | introduced: 2.2.0 3 | default: 128 4 | tags: 5 | - portability 6 | description: > 7 | Maximum length of fatal error message string when error is thrown by 8 | Duktape internals, in particular for uncaught errors. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FILE_IO.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FILE_IO 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: true 5 | tags: 6 | - io 7 | description: > 8 | File I/O support. This is now used in a few API calls to e.g. push 9 | a string from file contents or eval a file. For portability it must 10 | be possible to disable I/O altogether. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FINALIZER_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FINALIZER_SUPPORT 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - execution 6 | description: > 7 | Enable support for object finalizers (Duktape specific). 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FINALIZER_TORTURE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FINALIZER_TORTURE 2 | introduced: 2.1.0 3 | default: false 4 | tags: 5 | - gc 6 | - memory 7 | - development 8 | - torture 9 | description: > 10 | Development time option: simulate a fake finalizer call every time when 11 | finalizers might be executed (even if the actual finalize_list is empty). 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FLEX_C99.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FLEX_C99 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - portability 6 | description: > 7 | Use C99 flexible array member for defining variable size structures. 8 | 9 | # XXX: currently unused, remove or mark unused so doesn't get emitted? 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FLEX_ONESIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FLEX_ONESIZE 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use a single element array to define variable size structures. This is the 8 | most portable alternative: zero-size arrays are not allowed by all compilers 9 | and flexible array member ("char arr[]") is defined in C99. 10 | 11 | # XXX: currently unused, remove or mark unused so doesn't get emitted? 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FLEX_ZEROSIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FLEX_ZEROSIZE 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use a zero element array to define variable size structures. This is not 8 | fully portable but works with some compilers and is preferred over using 9 | a one element array. 10 | 11 | # XXX: currently unused, remove or mark unused so doesn't get emitted? 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FUNCPTR_ENC16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FUNCPTR_ENC16 2 | introduced: 1.1.0 3 | requires: 4 | - DUK_USE_FUNCPTR16 5 | default: false 6 | tags: 7 | - lowmemory 8 | - experimental 9 | description: > 10 | Use together with DUK_USE_FUNCPTR16 for arbitrary data pointer compression. 11 | DUK_USE_FUNCPTR_DEC16(udata,x) is a macro with a userdata and duk_uint16_t 12 | argument, and a void ptr return value. The userdata argument is the heap 13 | userdata value given at heap creation. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FUNCTION_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FUNCTION_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide a Function built-in. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FUNC_FILENAME_PROPERTY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FUNC_FILENAME_PROPERTY 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | - compliance 7 | description: > 8 | Add a non-standard ".fileName" property to function instances. Disabling 9 | reduces footprint. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_FUNC_NAME_PROPERTY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_FUNC_NAME_PROPERTY 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | - compliance 7 | description: > 8 | Add a "name" property to function instances. This is part of ECMAScript 9 | requirements, but low memory devices can sometimes opt to not include the 10 | .name to reduce footprint. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_GCC_PRAGMAS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_GCC_PRAGMAS 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use GCC-specific pragmas, e.g. "#pragma GCC diagnostic" to suppress 8 | unnecessary warnings. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_GC_TORTURE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_GC_TORTURE 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - gc 6 | - memory 7 | - development 8 | - torture 9 | description: > 10 | Development time option: force full mark-and-sweep on every allocation and 11 | in other chosen places to stress test memory management. 12 | 13 | Using a low value (e.g. 3) for DUK_USE_MARK_AND_SWEEP_RECLIMIT is also 14 | recommended. 15 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_GET_MONOTONIC_TIME_CLOCK_GETTIME.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_GET_MONOTONIC_TIME_CLOCK_GETTIME 2 | introduced: 2.2.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use clock_gettime(CLOCK_MONOTONIC, ...) for monotonic time on POSIX 8 | platforms. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_GET_MONOTONIC_TIME_WINDOWS_QPC.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_GET_MONOTONIC_TIME_WINDOWS_QPC 2 | introduced: 2.2.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use QueryPerformanceCounter() for monotonic time on Windows. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_GLOBAL_BINDING.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_GLOBAL_BINDING 2 | introduced: 2.1.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | - experimental 7 | description: > 8 | Provide a 'globalThis' binding (https://github.com/tc39/proposal-global). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_GLOBAL_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_GLOBAL_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide miscellaneous global built-ins like encodeURIComponent(), escape(), 8 | Infinity, etc. This is a catch-all for globals not covered by other options 9 | (like DUK_USE_ARRAY_BUILTIN). 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Allow unaligned 32-bit unsigned integer access in hashbytes algorithm. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HEAPPTR_DEC16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HEAPPTR_DEC16 2 | introduced: 1.1.0 3 | requires: 4 | - DUK_USE_HEAPPTR16 5 | default: false 6 | tags: 7 | - lowmemory 8 | - experimental 9 | description: > 10 | Use together with DUK_USE_HEAPPTR16 for heap pointer compression. 11 | DUK_USE_HEAPPTR_DEC16(udata,x) is a macro with a userdata and duk_uint16_t 12 | argument, and a void ptr return value. The userdata argument is the heap 13 | userdata value given at heap creation. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HEAPPTR_ENC16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HEAPPTR_ENC16 2 | introduced: 1.1.0 3 | requires: 4 | - DUK_USE_HEAPPTR16 5 | default: false 6 | tags: 7 | - lowmemory 8 | - experimental 9 | description: > 10 | Use together with DUK_USE_HEAPPTR16 for heap pointer compression. 11 | DUK_USE_HEAPPTR_ENC16(udata,p) is a macro with a userdata and void ptr 12 | argument, and a duk_uint16_t return value. The userdata argument is the 13 | heap userdata value given at heap creation. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HEX_FASTPATH.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HEX_FASTPATH 2 | introduced: 1.4.0 3 | default: true 4 | tags: 5 | - performance 6 | - fastpath 7 | - lowmemory 8 | description: > 9 | Enable fast path for hex encode/decode. The fast path uses a lookup 10 | table at a small cost in footprint. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HEX_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HEX_SUPPORT 2 | introduced: 2.3.0 3 | default: true 4 | tags: 5 | - codec 6 | description: > 7 | Enable hex encoding/decoding support. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HOBJECT_ARRAY_ABANDON_MINSIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HOBJECT_ARRAY_ABANDON_MINSIZE 2 | introduced: 2.5.0 3 | default: 257 4 | tags: 5 | - performance 6 | - lowmemory 7 | description: > 8 | Minimum array size required for array to be abandoned. For example, a value 9 | of 257 means arrays up to 256 long are never abandoned. The default value 10 | ensures 8-bit lookups are not abandoned even if sparse or initialized in 11 | random order. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HOBJECT_ARRAY_FAST_RESIZE_LIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HOBJECT_ARRAY_FAST_RESIZE_LIMIT 2 | introduced: 2.1.0 3 | default: 9 4 | tags: 5 | - performance 6 | - lowmemory 7 | description: > 8 | Skip abandon check in object array part resize if new_size < L * old_size. 9 | The limit L is expressed as a .3 fixed point value, e.g. 9 means 9/8 = 10 | 112.5% of current size. 11 | 12 | This is rather technical and you should only change the parameter if you've 13 | looked at the internals. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HOBJECT_ARRAY_MINGROW_ADD.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HOBJECT_ARRAY_MINGROW_ADD 2 | introduced: 2.1.0 3 | default: 16 4 | tags: 5 | - performance 6 | description: > 7 | Technical internal parameter, see sources for details. Only adjust if 8 | you've looked at the internals. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HOBJECT_ARRAY_MINGROW_DIVISOR.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HOBJECT_ARRAY_MINGROW_DIVISOR 2 | introduced: 2.1.0 3 | default: 8 4 | tags: 5 | - performance 6 | description: > 7 | Technical internal parameter, see sources for details. Only adjust if 8 | you've looked at the internals. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HOBJECT_ENTRY_MINGROW_ADD.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HOBJECT_ENTRY_MINGROW_DIVISOR 2 | introduced: 2.1.0 3 | default: 8 4 | tags: 5 | - performance 6 | description: > 7 | Technical internal parameter, see sources for details. Only adjust if 8 | you've looked at the internals. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HOBJECT_ENTRY_MINGROW_DIVISOR.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HOBJECT_ENTRY_MINGROW_ADD 2 | introduced: 2.1.0 3 | default: 16 4 | tags: 5 | - performance 6 | description: > 7 | Technical internal parameter, see sources for details. Only adjust if 8 | you've looked at the internals. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HOBJECT_HASH_PART.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HOBJECT_HASH_PART 2 | introduced: 1.1.0 3 | default: true 4 | tags: 5 | - lowmemory 6 | - experimental 7 | description: > 8 | Use a hash table for objects that have enough properties. This should be 9 | enabled unless the target is very low on memory. 10 | 11 | If DUK_USE_OBJSIZES16 is defined, this option must not be defined. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HOBJECT_LAYOUT_1.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HOBJECT_LAYOUT_1 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use layout variant 1 for object properties. Layout 1 can be used when the 8 | target has no alignment restrictions. It is preferable to other layouts 9 | because it produces smaller code and provides direct access to property 10 | keys. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HOBJECT_LAYOUT_2.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HOBJECT_LAYOUT_2 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - portability 6 | description: > 7 | Use layout variant 2 for object properties. Layout 2 can be used on any 8 | target (including targets with alignment restrictions). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HOBJECT_LAYOUT_3.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HOBJECT_LAYOUT_3 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use layout variant 3 for object properties. Layout 3 can be used on any 8 | target (including targets with alignment restrictions). It's a bit more 9 | packed than layout variant 2 but has a bit slower lookups. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HSTRING_ARRIDX.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HSTRING_ARRIDX 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - lowmemory 6 | description: > 7 | When enabled, duk_hstring stores a precomputed array index (or "not an array 8 | index") value related to the string. This reduces code footprint and 9 | improves performance a littl ebit. 10 | 11 | When disabled, duk_hstring has a flag indicating whether it is an array 12 | index or not, but the actual value is computed on-the-fly. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HSTRING_CLEN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HSTRING_CLEN 2 | introduced: 1.5.0 3 | default: true 4 | tags: 5 | - lowmemory 6 | - experimental 7 | description: > 8 | When DUK_USE_STRLEN16 enabled, indicates whether the character length 9 | (clen16) field should be actually present (default) or computed on-the-fly. 10 | 11 | When clen is computed on-the-fly the duk_hstring structure will be 4 bytes 12 | smaller (from 10 bytes + 2 bytes padding to 8 bytes) which may be useful for 13 | very low memory targets. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HSTRING_EXTDATA.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HSTRING_EXTDATA 2 | introduced: 1.1.0 3 | default: false 4 | tags: 5 | - memory 6 | description: > 7 | Enable support for external strings. An external string requires a Duktape 8 | heap allocation to store a minimal string header, with the actual string 9 | data being held behind a pointer (similarly to how dynamic buffers work). 10 | 11 | This option is needed to use DUK_USE_EXTSTR_INTERN_CHECK and/or 12 | DUK_USE_EXTSTR_FREE. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HSTRING_LAZY_CLEN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HSTRING_LAZY_CLEN 2 | introduced: 2.2.0 3 | default: true 4 | tags: 5 | - performance 6 | description: > 7 | When enabled, duk_hstring charlen is computed only when accessed; because 8 | the charlen of most strings is not accessed during their lifetime, this 9 | reduces unnecessary charlen calculations. When disabled, charlen is computed 10 | during interning which has smaller code footprint at slightly slower charlen 11 | handling. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_HTML_COMMENTS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_HTML_COMMENTS 2 | introduced: 2.1.0 3 | default: true 4 | tags: 5 | - ecmascript2015 6 | description: > 7 | Enable ES2015 Annex B.1.3 HTML comment syntax. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_IDCHAR_FASTPATH.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_IDCHAR_FASTPATH 2 | introduced: 1.5.0 3 | default: true 4 | tags: 5 | - performance 6 | - fastpath 7 | - lowmemory 8 | description: > 9 | Enable fast path for identifier start/part tables, which affect lexing and 10 | JSON performance slightly at a small cost in footprint. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_INJECT_HEAP_ALLOC_ERROR.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_INJECT_HEAP_ALLOC_ERROR 2 | introduced: 2.1.0 3 | default: false 4 | tags: 5 | - development 6 | description: > 7 | Force heap allocation to fail, value indicates the desired error position. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_INTEGER_BE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_INTEGER_BE 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: false 5 | conflicts: 6 | - DUK_USE_INTEGER_LE 7 | - DUK_USE_INTEGER_ME 8 | tags: 9 | - portability 10 | description: > 11 | Integer memory representation is big endian on the target platform. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_INTEGER_LE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_INTEGER_LE 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: true 5 | conflicts: 6 | - DUK_USE_INTEGER_BE 7 | - DUK_USE_INTEGER_ME 8 | tags: 9 | - portability 10 | description: > 11 | Integer memory representation is little endian on the target platform. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_INTEGER_ME.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_INTEGER_ME 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: false 5 | conflicts: 6 | - DUK_USE_INTEGER_LE 7 | - DUK_USE_INTEGER_BE 8 | tags: 9 | - portability 10 | description: > 11 | Integer memory representation is mixed endian on the target platform. 12 | 13 | This option is unused (and unsupported) because no target platform currently 14 | needs this. 15 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_INTERRUPT_COUNTER.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_INTERRUPT_COUNTER 2 | introduced: 1.1.0 3 | related: 4 | - DUK_USE_DEBUGGER_SUPPORT 5 | default: false 6 | tags: 7 | - execution 8 | - debugger 9 | description: > 10 | Enable the internal bytecode executor periodic interrupt counter. 11 | The mechanism is used to implement e.g. execution step limit, custom 12 | profiling, and debugger interaction. Enabling the interrupt counter 13 | has a small impact on execution performance. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_INTERRUPT_DEBUG_FIXUP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_INTERRUPT_DEBUG_FIXUP 2 | introduced: 1.4.0 3 | default: false 4 | tags: 5 | - development 6 | description: > 7 | For Duktape development only: enable "interrupt fixup" in call handling 8 | so that heap->inst_count_exec and heap->inst_count_interrupt can be 9 | manually checked to match. Only useful when debugging and/or asserts 10 | are enabled. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_JC.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_JC 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Enable support for the JC custom JSON format. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_JSON_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_JSON_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide a JSON built-in. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_JSON_DECNUMBER_FASTPATH.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_JSON_DECNUMBER_FASTPATH 2 | introduced: 1.3.0 3 | default: true 4 | tags: 5 | - performance 6 | - fastpath 7 | - lowmemory 8 | description: > 9 | Enable fast path for decoding numbers in JSON.parse(). The fast path uses 10 | a lookup table at a small cost in footprint. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_JSON_DECSTRING_FASTPATH.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_JSON_DECSTRING_FASTPATH 2 | introduced: 1.3.0 3 | default: true 4 | tags: 5 | - performance 6 | - fastpath 7 | - lowmemory 8 | description: > 9 | Enable fast path for string decoding in JSON.parse(). The fast path uses 10 | a lookup table at a small cost in footprint. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_JSON_DEC_RECLIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_JSON_DEC_RECLIMIT 2 | introduced: 1.3.0 3 | default: 1000 4 | tags: 5 | - portability 6 | - cstackdepth 7 | description: > 8 | Maximum native stack recursion for JSON decoding. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_JSON_EATWHITE_FASTPATH.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_JSON_EATWHITE_FASTPATH 2 | introduced: 1.3.0 3 | default: true 4 | tags: 5 | - performance 6 | - fastpath 7 | - lowmemory 8 | description: > 9 | Enable fast path for eating whitespace in JSON.parse(). The fast path uses 10 | a lookup table at a small cost in footprint. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_JSON_ENC_RECLIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_JSON_ENC_RECLIMIT 2 | introduced: 1.3.0 3 | default: 1000 4 | tags: 5 | - portability 6 | - cstackdepth 7 | description: > 8 | Maximum native stack recursion for JSON encoding. 9 | 10 | Must be higher than the internal DUK_JSON_ENC_LOOPARRAY define when 11 | DUK_USE_JSON_STRINGIFY_FASTPATH is enabled. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_JSON_QUOTESTRING_FASTPATH.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_JSON_QUOTESTRING_FASTPATH 2 | introduced: 1.3.0 3 | default: true 4 | tags: 5 | - performance 6 | - fastpath 7 | - lowmemory 8 | description: > 9 | Enable fast path for string quoting in JSON.stringify(). The fast path uses 10 | a lookup table at a small cost in footprint. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_JSON_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_JSON_SUPPORT 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Enable JSON functionality, affects both ECMAScript and C APIs. 8 | Note that disabling DUK_USE_JSON_BUILTIN still leaves the C API intact 9 | and pulls in the JSON encoding/decoding functionality; disable this 10 | option to remove that too. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_JX.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_JX 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Enable support for the JX custom JSON format. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_LEXER_SLIDING_WINDOW.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_LEXER_SLIDING_WINDOW 2 | introduced: 1.3.0 3 | default: true 4 | tags: 5 | - lowmemory 6 | description: > 7 | Use a sliding window approach for managing the lexer codepoint lookup window 8 | (recommended). If disabled, the lexer uses a slower algorithm which has a 9 | slightly smaller code and RAM footprint. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_LIGHTFUNC_BUILTINS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_LIGHTFUNC_BUILTINS 2 | introduced: 1.1.0 3 | default: false 4 | tags: 5 | - lowmemory 6 | - experimental 7 | description: > 8 | Force built-in functions to be lightweight functions. This reduces 9 | memory footprint by around 14 kB at the cost of some non-compliant 10 | behavior. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_MARK_AND_SWEEP_RECLIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_MARK_AND_SWEEP_RECLIMIT 2 | introduced: 1.3.0 3 | default: 256 4 | tags: 5 | - portability 6 | - cstackdepth 7 | description: > 8 | Mark-and-sweep C recursion depth for marking phase; if reached, 9 | mark object as a TEMPROOT and use multi-pass marking (slower but 10 | same result). 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_MATH_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_MATH_BUILTIN 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide a Math built-in. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_MS_STRINGTABLE_RESIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_MS_STRINGTABLE_RESIZE 2 | introduced: 1.0.0 3 | removed: 2.1.0 4 | default: true 5 | tags: 6 | - gc 7 | - memory 8 | description: > 9 | Enable forced string intern table resize during mark-and-sweep garbage 10 | collection. This is the recommended behavior. 11 | 12 | It may be useful to disable this option when reference counting is disabled, 13 | as mark-and-sweep collections will be more frequent and thus more expensive. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_NATIVE_CALL_RECLIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_NATIVE_CALL_RECLIMIT 2 | introduced: 1.3.0 3 | default: 1000 4 | tags: 5 | - portability 6 | - cstackdepth 7 | description: > 8 | Maximum duk_handle_call() / duk_handle_safe_call() C recursion limit. 9 | Note that this does not limit bytecode executor internal call depth at 10 | all (e.g. for ECMAScript-to-ECMAScript calls, thread yields/resumes, etc). 11 | There is a separate callstack depth limit for threads which is independent 12 | of this limit. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER 2 | introduced: 1.0.0 3 | removed: 2.3.0 4 | default: true 5 | tags: 6 | - ecmascript 7 | - compliance 8 | description: > 9 | In ES5.1 trailing gaps of an argument array don't count towards the result 10 | length. This is in essence a specification "bug" which was fixed in ES2015. 11 | This option was removed in 2.3.0, and the remaining behavior matches ES2015. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - ecmascript 6 | - compliance 7 | description: > 8 | Add a non-standard "source" property to function instances. This allows 9 | function toString() to print out the actual function source. The property 10 | is disabled by default because it increases memory footprint. 11 | 12 | NOTE: Unimplemented as of Duktape 1.3.0. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_NONSTD_GETTER_KEY_ARGUMENT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_NONSTD_GETTER_KEY_ARGUMENT 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | - compliance 7 | description: > 8 | Give getter calls the accessed property name as an additional non-standard 9 | argument. This allows a single getter function to be reused for multiple 10 | properties more easily. See 11 | http://duktape.org/guide.html#propertyvirtualization. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: true 5 | tags: 6 | - ecmascript 7 | - compliance 8 | description: > 9 | Replaced by DUK_USE_ES6_REGEXP_SYNTAX. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_NONSTD_SETTER_KEY_ARGUMENT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_NONSTD_SETTER_KEY_ARGUMENT 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | - compliance 7 | description: > 8 | Give setter calls the accessed property name as an additional non-standard 9 | argument. This allows a single setter function to be reused for multiple 10 | properties more easily. See 11 | http://duktape.org/guide.html#propertyvirtualization. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT 2 | introduced: 1.2.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | - compliance 7 | description: > 8 | Allow 32-bit codepoints in String.fromCharCode(). This is non-compliant 9 | (the E5.1 specification has a ToUint16() coercion for the codepoints) but 10 | useful because Duktape supports non-BMP strings. 11 | 12 | When disabled, Duktape provides the compliant behavior. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_NO_DOUBLE_ALIASING_SELFTEST.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_NO_DOUBLE_ALIASING_SELFTEST 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Disable double aliasing selftest (if self tests enabled). 9 | 10 | Double aliasing testcase fails when Emscripten-generated code is run. 11 | This is not fatal because it only affects packed duk_tval which we 12 | avoid with Emscripten. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_NUMBER_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_NUMBER_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide a Number built-in. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_OBJECT_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_OBJECT_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide an Object built-in. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_OBJSIZES16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_OBJSIZES16 2 | introduced: 1.1.0 3 | default: false 4 | tags: 5 | - lowmemory 6 | - experimental 7 | description: > 8 | Use a 16-bit object entry and array part sizes (for low memory 9 | environments). Also automatically drops support for an object hash part 10 | to further reduce memory usage; there are rarely large objects in low 11 | memory environments simply because there's no memory to store a lot of 12 | properties. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_OCTAL_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_OCTAL_SUPPORT 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: true 5 | tags: 6 | - ecmascript 7 | description: > 8 | Enable optional octal number support (ECMAScript E5/E5.1 9 | Annex B: http://www.ecma-international.org/ecma-262/5.1/#sec-B). 10 | Recommended because existing code bases use octal numbers. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_OS_STRING.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_OS_STRING 2 | introduced: 1.0.0 3 | default: 4 | string: "unknown" 5 | tags: 6 | - portability 7 | description: > 8 | Human-readable operating system string used in e.g. Duktape.env and debugger 9 | protocol (example: linux). 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PACKED_TVAL.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PACKED_TVAL 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use a packed 8-byte representation for duk_tval. The packed representation 8 | represents non-number values as special IEEE double NaN values, and is only 9 | possible for platforms with 32-bit pointers. When the packed representation 10 | is not available, Duktape uses a 12-16 byte struct/union which is more 11 | portable. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PACKED_TVAL_POSSIBLE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PACKED_TVAL_POSSIBLE 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Define when packed, 8-byte duk_tval representation is possible. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PACK_CLANG_ATTR.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PACK_CLANG_ATTR 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use clang-specific attribute to force struct packing. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PACK_DUMMY_MEMBER.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PACK_DUMMY_MEMBER 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use dummy struct member to force struct packing. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PACK_GCC_ATTR.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PACK_GCC_ATTR 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use gcc-specific attribute to force struct packing. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PACK_MSVC_PRAGMA.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PACK_MSVC_PRAGMA 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Use msvc-specific attribute to force struct packing. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PANIC_ABORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PANIC_ABORT 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: true 5 | tags: 6 | - portability 7 | description: > 8 | Call abort() when the default panic handler is invoked. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PANIC_EXIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PANIC_EXIT 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Call exit() when the default panic handler is invoked. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PANIC_HANDLER.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PANIC_HANDLER 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Provide a custom panic handler. A custom panic handler is recommended for 9 | any environment where recovery from fatal errors is important. A custom 10 | handler can take appropriate action to recover, e.g. record the error and 11 | reboot the target device. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PANIC_SEGFAULT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PANIC_SEGFAULT 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Cause an intentional segfault when the default panic handler is invoked. 9 | This is useful when debugging with valgrind because a segfault provides 10 | a nice C traceback in valgrind. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PARANOID_MATH.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PARANOID_MATH 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Rely as little as possible on compiler behavior for NaN comparison, 8 | signed zero handling, etc. May be needed for (very) broken compilers. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PC2LINE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PC2LINE 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Record a "pc2line" map into function instances which allows bytecode program 8 | counter values to be mapped into line numbers e.g. in error tracebacks. 9 | 10 | Without this map, exceptions won't have meaningful line numbers but function 11 | instances will have a smaller footprint. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PERFORMANCE_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PERFORMANCE_BUILTIN 2 | introduced: 2.2.0 3 | default: true 4 | tags: 5 | - performance-api 6 | description: > 7 | Provide a 'performance' global object based on https://www.w3.org/TR/hr-time/. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_POW_NETBSD_WORKAROUND.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_POW_NETBSD_WORKAROUND 2 | introduced: 1.0.0 3 | removed: 2.0.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | NetBSD 6.0 x86 (at least) has a few problems with pow() semantics, 9 | see test-bug-netbsd-math-pow.js. Use NetBSD specific workaround. 10 | 11 | (This might be a wider problem; if so, generalize the define name.) 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_POW_WORKAROUNDS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_POW_WORKAROUNDS 2 | introduced: 2.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Enable workarounds to common pow() semantics issues. At least NetBSD 8 | 6.0 x86 and Cygwin/MinGW have such issues, see test-bug-netbsd-math-pow.js 9 | and test-bug-mingw-math-issues.js. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PREFER_SIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PREFER_SIZE 2 | introduced: 1.2.0 3 | default: false 4 | tags: 5 | - lowmemory 6 | description: > 7 | Catch-all flag which can be used to choose between variant algorithms 8 | where a speed-size tradeoff exists (e.g. lookup tables). When it really 9 | matters, specific use flags may be appropriate. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PROMISE_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PROMISE_BUILTIN 2 | introduced: 2.2.0 3 | default: false # disabled until fully functional 4 | tags: 5 | - ecmascript 6 | description: > 7 | Enable Promise built-in. 8 | 9 | At present entirely non-functional, and disabled by default. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - portability 6 | description: > 7 | Provide default allocation functions. 8 | 9 | At the moment this option should be enabled. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_RDTSC.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_RDTSC 2 | introduced: 1.3.0 3 | removed: 1.4.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Macro to provide an x86/x64 RDTSC timestamp for debug prints. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REFCOUNT16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REFCOUNT16 2 | introduced: 1.1.0 3 | default: false 4 | tags: 5 | - lowmemory 6 | - experimental 7 | - gc 8 | description: > 9 | Use a 16-bit reference count field (for low memory environments). 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REFCOUNT32.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REFCOUNT32 2 | introduced: 2.1.0 3 | default: true 4 | tags: 5 | - gc 6 | description: > 7 | Use a 32-bit reference count field. 8 | 9 | While on some 64-bit systems it's theoretically possible to wrap a 32-bit 10 | counter field, assuming a 16-byte duk_tval the Duktape heap would have to 11 | be larger than 64GB for that to happen. Because of this the default is to 12 | use a 32-bit refcount field. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REFERENCE_COUNTING.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REFERENCE_COUNTING 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - gc 6 | description: > 7 | Use reference counting for garbage collection. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REFLECT_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REFLECT_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript2015 6 | description: > 7 | Provide a Reflect built-in. The ES6 Reflect object provides a collection of 8 | methods for examining and manipulating objects at runtime. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REFZERO_FINALIZER_TORTURE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REFZERO_FINALIZER_TORTURE 2 | introduced: 1.3.0 3 | removed: 2.1.0 4 | related: 5 | - DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE 6 | default: false 7 | tags: 8 | - gc 9 | - memory 10 | - development 11 | - torture 12 | description: > 13 | Development time option: simulate a fake finalizer call for every object 14 | going through refzero freeing. This is useful to detect bugs caused by 15 | finalizer side effects in e.g. call handling. 16 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REGEXP_CANON_BITMAP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REGEXP_CANON_BITMAP 2 | introduced: 2.2.0 3 | default: true 4 | tags: 5 | - performance 6 | - unicode 7 | description: > 8 | Use a small lookup table (footprint impact is ~300-400 bytes) to speed up 9 | case insensitive RegExp canonicalization. The result is still much slower 10 | than with DUK_USE_REGEXP_CANON_WORKAROUND but ~50x faster than without the 11 | lookup. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REGEXP_CANON_WORKAROUND.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REGEXP_CANON_WORKAROUND 2 | introduced: 1.4.0 3 | default: false 4 | tags: 5 | - performance 6 | - unicode 7 | - experimental 8 | description: > 9 | Use a 128kB lookup table for RegExp codepoint canonicalization to improve 10 | performance of case insensitive RegExp handling. 11 | 12 | This is a temporary workaround until there's better support for faster 13 | Unicode handling. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REGEXP_COMPILER_RECLIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REGEXP_COMPILER_RECLIMIT 2 | introduced: 1.3.0 3 | default: 10000 4 | tags: 5 | - portability 6 | - cstackdepth 7 | description: > 8 | RegExp compiler native call stack recursion limit. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REGEXP_EXECUTOR_RECLIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REGEXP_EXECUTOR_RECLIMIT 2 | introduced: 1.3.0 3 | default: 10000 4 | tags: 5 | - portability 6 | - cstackdepth 7 | description: > 8 | RegExp executor native call stack recursion limit. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REPL_FPCLASSIFY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REPL_FPCLASSIFY 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Provide a built-in replacement for fpclassify(), duk_repl_fpclassify. 8 | 9 | When enabled, define DUK_FPCLASSIFY as duk_repl_fpclassify. 10 | 11 | # XXX: the dependency between DUK_USE_REPL_FPCLASSIFY and DUK_FPCLASSIFY 12 | # is a bit awkward. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REPL_ISFINITE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REPL_ISFINITE 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Provide a built-in replacement for isfinite(), duk_repl_isfinite. 8 | 9 | When enabled, define DUK_ISFINITE as duk_repl_isfinite. 10 | 11 | # XXX: the dependency between DUK_USE_REPL_ISFINITE and DUK_ISFINITE 12 | # is a bit awkward. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REPL_ISINF.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REPL_ISINF 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Provide a built-in replacement for isinf(), duk_repl_isinf. 8 | 9 | When enabled, define DUK_ISINF as duk_repl_isinf. 10 | 11 | # XXX: the dependency between DUK_USE_REPL_ISINF and DUK_ISINF 12 | # is a bit awkward. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REPL_ISNAN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REPL_ISNAN 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Provide a built-in replacement for isnan(), duk_repl_isnan. 8 | 9 | When enabled, define DUK_ISNAN as duk_repl_isnan. 10 | 11 | # XXX: the dependency between DUK_USE_REPL_ISNAN and DUK_ISNAN 12 | # is a bit awkward. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_REPL_SIGNBIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_REPL_SIGNBIT 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Provide a built-in replacement for signbit(), duk_repl_signbit. 8 | 9 | When enabled, define DUK_SIGNBIT as duk_repl_signbit. 10 | 11 | # XXX: the dependency between DUK_USE_REPL_SIGNBIT and DUK_SIGNBIT 12 | # is a bit awkward. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_SECTION_B.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_SECTION_B 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Enable optional features in ECMAScript specification 8 | Annex B: http://www.ecma-international.org/ecma-262/5.1/#sec-B. 9 | 10 | When disabled, escape(), unescape(), and String.prototype.substr() 11 | throw an error. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_SELF_TESTS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_SELF_TESTS 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - debug 6 | description: > 7 | Perform run-time self tests when a Duktape heap is created. Catches 8 | platform/compiler problems which cannot be reliably detected during 9 | compile time. Not enabled by default because of the extra footprint. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_SHEBANG_COMMENTS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_SHEBANG_COMMENTS 2 | introduced: 2.1.0 3 | default: true 4 | tags: 5 | - ecmascript2015 6 | description: > 7 | Support parsing of a "shebang" comment ('#!...') on the first line of 8 | source text. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_SHUFFLE_TORTURE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_SHUFFLE_TORTURE 2 | introduced: 1.2.0 3 | default: false 4 | tags: 5 | - gc 6 | - memory 7 | - development 8 | - torture 9 | description: > 10 | Development time option: force compiler to shuffle every possible opcode 11 | to stress shuffle behavior which is otherwise difficult to test for 12 | comprehensively. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_SIGSETJMP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_SIGSETJMP 2 | introduced: 1.1.0 3 | removed: 1.5.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Use sigsetjmp/siglongjmp with savesigs == 0 for long control 9 | transfers (i.e. signal mask not saved/restored). See comments in 10 | DUK_USE_SETJMP. 11 | 12 | Removed in Duktape 1.5.0: edit duk_config.h directly. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_SOURCE_NONBMP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_SOURCE_NONBMP 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | - lowmemory 7 | description: > 8 | Enable accurate Unicode support for non-BMP characters in source code. 9 | 10 | When disabled non-BMP characters are always accepted as identifier 11 | characters. Disabling this option saves a little bit of code footprint. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRHASH16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRHASH16 2 | introduced: 1.1.0 3 | default: false 4 | tags: 5 | - lowmemory 6 | - experimental 7 | description: > 8 | Use a 16-bit string hash field (for low memory environments). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRHASH_DENSE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRHASH_DENSE 2 | introduced: 1.4.0 3 | default: false 4 | tags: 5 | - performance 6 | - sandbox 7 | description: > 8 | Use the slower but more dense string hash algorithm from Duktape 1.3.0 and 9 | prior (based on Murmurhash2). This may be useful if you're experiencing 10 | collision issues with the default hash algorithm. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRHASH_SKIP_SHIFT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRHASH_SKIP_SHIFT 2 | introduced: 1.4.0 3 | default: 5 4 | tags: 5 | - performance 6 | description: > 7 | Shift value to use for string hash skip offset when using the default 8 | (fast) string hash. The skip offset is calculated as: 9 | ((length >> DUK_USE_STRHASH_SKIP_SHIFT) + 1). A higher value will be 10 | slower but sample the string more densely. 11 | 12 | You should only change this if you run into issues with the default value. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRICT_UTF8_SOURCE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRICT_UTF8_SOURCE 2 | introduced: 1.0.0 3 | default: false 4 | tags: 5 | - ecmascript 6 | description: > 7 | Enable strict UTF-8 parsing of source code. 8 | 9 | When disabled, non-shortest encodings (normally invalid UTF-8) and surrogate 10 | pair codepoints are accepted as valid source code characters. Disabling 11 | this option breaks compatibility with some test262 tests. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRING_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRING_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide a String built-in. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRLEN16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRLEN16 2 | introduced: 1.1.0 3 | default: false 4 | tags: 5 | - lowmemory 6 | - experimental 7 | description: > 8 | Use a 16-bit string length field (for low memory environments). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRTAB_CHAIN_SIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRTAB_CHAIN_SIZE 2 | introduced: 1.1.0 3 | removed: 2.1.0 4 | requires: 5 | - DUK_USE_STRTAB_CHAIN 6 | default: false 7 | tags: 8 | - lowmemory 9 | description: > 10 | Define stringtable size for DUK_USE_STRTAB_CHAIN. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRTAB_GROW_LIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRTAB_GROW_LIMIT 2 | introduced: 2.1.0 3 | default: 17 # 17/16 = 1.0625 4 | tags: 5 | - performance 6 | - lowmemory 7 | description: > 8 | Grow top level strtable allocation when load factor reaches this value. 9 | Expressed as a .4 fixed point; the load factor is computed as 10 | floor((count / size) * 16.0), e.g. 32 means a load factor of 2.0. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRTAB_MAXSIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRTAB_MAXSIZE 2 | introduced: 2.1.0 3 | default: 268435456 4 | tags: 5 | - performance 6 | - lowmemory 7 | description: > 8 | Maximum size for Duktape heap string table, must be 2^N, and small enough 9 | so that if the value is multiplied by sizeof(duk_hstring *) it won't overflow 10 | duk_size_t. 11 | 12 | To avoid resizing the strtable at all, set DUK_USE_STRTAB_MINSIZE and 13 | DUK_USE_STRTAB_MAXSIZE to the same value. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRTAB_MINSIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRTAB_MINSIZE 2 | introduced: 2.1.0 3 | default: 1024 4 | tags: 5 | - performance 6 | - lowmemory 7 | description: > 8 | Minimum size for Duktape heap string table, must be 2^N, and should never 9 | be lower than 64. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRTAB_PROBE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRTAB_PROBE 2 | introduced: 1.1.0 3 | removed: 2.1.0 4 | default: true 5 | tags: 6 | - lowmemory 7 | description: > 8 | Use the default open addressing (probing) based string table algorithm. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRTAB_SHRINK_LIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRTAB_SHRINK_LIMIT 2 | introduced: 2.1.0 3 | default: 6 # 6/16 = 0.375 4 | tags: 5 | - performance 6 | - lowmemory 7 | description: > 8 | Shrink top level strtable allocation when load factor reaches this value. 9 | Expressed as a .4 fixed point; the load factor is computed as 10 | floor((count / size) * 16.0), e.g. 8 means a load factor of 0.5. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_STRTAB_TORTURE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_STRTAB_TORTURE 2 | introduced: 2.1.0 3 | default: false 4 | tags: 5 | - torture 6 | description: > 7 | Resize string table (grow, shrink back) for every intern. Ensures string 8 | table chaining is correct, and resize side effects are exercised on every 9 | resize. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_SYMBOL_BUILTIN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_SYMBOL_BUILTIN 2 | introduced: 2.0.0 3 | default: true 4 | tags: 5 | - ecmascript2015 6 | description: > 7 | Provide ES6 Symbol built-ins. 8 | 9 | Even with the built-ins disabled, symbols created by C code are still 10 | supported. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_TAILCALL.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_TAILCALL 2 | introduced: 1.0.0 3 | conflicts: 4 | - DUK_USE_NONSTD_FUNC_CALLER_PROPERTY 5 | default: true 6 | tags: 7 | - ecmascript 8 | description: > 9 | Enable tail call support (recommended). 10 | 11 | The non-standard function 'caller' property feature conflicts with 12 | tailcalls quite severely so tailcalls must be disabled if the 'caller' 13 | property is enabled. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_TARGET_INFO.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_TARGET_INFO 2 | introduced: 1.2.0 3 | default: 4 | string: "unknown" 5 | tags: 6 | - debugger 7 | description: > 8 | Define a freeform human readable string to describe the target device (e.g. 9 | "Arduino Yun"). This string will be sent as part of version/target info in 10 | the debugger protocol and shows up in the debugger UI. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_TRACEBACKS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_TRACEBACKS 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Record traceback data into ECMAScript error objects. 8 | 9 | When disabled, traceback data is not recorded, but fileName/lineNumber of 10 | the error cause are still recorded as explicit properties. Disabling this 11 | option reduces footprint and makes error handling a bit faster, at the cost 12 | of less informative ECMAScript errors. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_UNALIGNED_ACCESSES_POSSIBLE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_UNALIGNED_ACCESSES_POSSIBLE 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Target architecture unaligned memory accesses (e.g. 32-bit integer access 9 | from an arbitrary address). 10 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_UNDERSCORE_SETJMP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_UNDERSCORE_SETJMP 2 | introduced: 1.1.0 3 | removed: 1.5.0 4 | default: false 5 | tags: 6 | - portability 7 | description: > 8 | Use _setjmp/_longjmp for long control transfers. This ensures signal 9 | mask is not saved which can be a lot faster if setjmp/longjmp saves the 10 | signal mask (this varies between platforms). See comments in 11 | DUK_USE_SETJMP. 12 | 13 | Removed in Duktape 1.5.0: edit duk_config.h directly. 14 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_UNION_INITIALIZERS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_UNION_INITIALIZERS 2 | introduced: 1.5.0 3 | default: false 4 | tags: 5 | - portability 6 | description: > 7 | Compiler supports C99-style designated union initializers, e.g. 8 | { .foo = 123 }. 9 | 10 | When disabled, Duktape sometimes needs to resort to less efficient struct 11 | initializers for portability. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_VALSTACK_LIMIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_VALSTACK_LIMIT 2 | introduced: 2.2.0 3 | default: 1000000 4 | tags: 5 | - misc 6 | description: > 7 | Maximum value stack size. If value stack is about to be grown beyond this 8 | size (the check includes a possible spare so the check isn't exact) reject 9 | the resize. The limit must be low enough so that when multiplied by 10 | sizeof(duk_tval), typically 8 or 16, the multiplication won't overflow 11 | size_t. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_VALSTACK_SHRINK_SLACK_SHIFT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_VALSTACK_SHRINK_SLACK_SHIFT 2 | introduced: 2.2.0 3 | default: 4 4 | tags: 5 | - performance 6 | - lowmemory 7 | description: > 8 | When shrinking, leave (curr_size >> DUK_USE_VALSTACK_SHRINK_SLACK_SHIFT) 9 | bytes as a slack. This shift count must be larger than 10 | DUK_USE_VALSTACK_SHRINK_CHECK_SHIFT. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_VALSTACK_UNSAFE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_VALSTACK_UNSAFE 2 | introduced: 1.2.0 3 | default: false 4 | tags: 5 | - performance 6 | - experimental 7 | description: > 8 | Don't check allocated value stack size in operations like value stack 9 | pushes. Improves performance of API calls but causes unsafe memory 10 | behavior (e.g. a segfault) when user code pushes beyond "checked" value 11 | stack size. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_VARIADIC_MACROS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_VARIADIC_MACROS 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - portability 6 | description: > 7 | Compiler supports C99-style variadic macros. Highly recommended to enable 8 | when possible. 9 | 10 | When disabled, Duktape needs to resort to various hacks to work around 11 | missing support for variadic macros. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_VERBOSE_ERRORS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_VERBOSE_ERRORS 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Provide error message strings and file/line information for errors generated 8 | by Duktape. 9 | 10 | When disabled, reduces footprint at the cost of much less informative 11 | ECMAScript errors. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_VERBOSE_EXECUTOR_ERRORS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_VERBOSE_EXECUTOR_ERRORS 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - ecmascript 6 | description: > 7 | Use verbose error messages in bytecode executor (recommended). 8 | 9 | When disabled, reduces footprint slightly at the cost of more obscure 10 | error messages. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/config-options/DUK_USE_ZERO_BUFFER_DATA.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_USE_ZERO_BUFFER_DATA 2 | introduced: 1.0.0 3 | default: true 4 | tags: 5 | - memory 6 | - ecmascript 7 | description: > 8 | Zero data are of newly allocated buffer values (recommended). 9 | 10 | When disabled, buffers are not zeroed and may contain arbitrary data. 11 | Disabling this option only makes sense for performance reasons. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/examples/disable_bufferobjects.yaml: -------------------------------------------------------------------------------- 1 | # Disable support for typed arrays and Node.js Buffer. Duktape will still 2 | # support plain buffers and Duktape.Buffer. 3 | DUK_USE_BUFFEROBJECT_SUPPORT: false 4 | -------------------------------------------------------------------------------- /deps/duktape/config/examples/disable_es6.yaml: -------------------------------------------------------------------------------- 1 | # Disable ES2015 features. 2 | 3 | DUK_USE_ES6_OBJECT_PROTO_PROPERTY: false 4 | DUK_USE_ES6_OBJECT_SETPROTOTYPEOFS: false 5 | DUK_USE_ES6_PROXY: false 6 | -------------------------------------------------------------------------------- /deps/duktape/config/examples/enable_debug_print0.yaml: -------------------------------------------------------------------------------- 1 | # Enable debug level 0. 2 | DUK_USE_DEBUG: true 3 | DUK_USE_DEBUG_LEVEL: 0 4 | -------------------------------------------------------------------------------- /deps/duktape/config/examples/enable_debug_print1.yaml: -------------------------------------------------------------------------------- 1 | # Enable debug level 1. 2 | DUK_USE_DEBUG: true 3 | DUK_USE_DEBUG_LEVEL: 1 4 | -------------------------------------------------------------------------------- /deps/duktape/config/examples/enable_debug_print2.yaml: -------------------------------------------------------------------------------- 1 | # Enable debug level 2. 2 | DUK_USE_DEBUG: true 3 | DUK_USE_DEBUG_LEVEL: 2 4 | -------------------------------------------------------------------------------- /deps/duktape/config/examples/enable_fastint.yaml: -------------------------------------------------------------------------------- 1 | # Enable fastint support. 2 | 3 | DUK_USE_FASTINT: true 4 | -------------------------------------------------------------------------------- /deps/duktape/config/examples/shallow_c_stack.yaml: -------------------------------------------------------------------------------- 1 | # Reduce recursion limits for shallow C stack targets. 2 | # These values are based on the (removed) DUK_USE_DEEP_C_STACK option. 3 | 4 | DUK_USE_NATIVE_CALL_RECLIMIT: 60 5 | DUK_USE_COMPILER_RECLIMIT: 50 6 | DUK_USE_REGEXP_COMPILER_RECLIMIT: 100 7 | DUK_USE_REGEXP_EXECUTOR_RECLIMIT: 100 8 | DUK_USE_JSON_ENC_RECLIMIT: 100 9 | DUK_USE_JSON_DEC_RECLIMIT: 100 10 | DUK_USE_MARK_AND_SWEEP_RECLIMIT: 32 11 | -------------------------------------------------------------------------------- /deps/duktape/config/examples/timing_sensitive.yaml: -------------------------------------------------------------------------------- 1 | # Base configuration for timing sensitive environments, see 2 | # doc/timing-sensitive.rst: 3 | 4 | DUK_USE_MARK_AND_SWEEP: true 5 | DUK_USE_REFERENCE_COUNTING: true 6 | DUK_USE_VOLUNTARY_GC: false 7 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_ASSERTIONS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_ASSERTIONS 2 | introduced: 1.0.0 3 | tags: 4 | - development 5 | - debug 6 | description: > 7 | Enable internal assert checks. These slow down execution considerably 8 | so only use when debugging. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_BUFFEROBJECT_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_BUFFEROBJECT_SUPPORT 2 | introduced: 1.3.0 3 | tags: 4 | - ecmascript6 5 | description: > 6 | Enable support for Khronos/ES6 typed arrays and Node.js Buffer objects. 7 | This adds about 8-9 kB of code footprint on x64. When disabled, Duktape 8 | custom plain buffers and Duktape.Buffer are still supported. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_BUFLEN16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_BUFLEN16 2 | introduced: 1.1.0 3 | tags: 4 | - lowmemory 5 | - experimental 6 | description: > 7 | Use a 16-bit buffer length field (for low memory environments). 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DATAPTR_DEC16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DATAPTR_DEC16 2 | introduced: 1.1.0 3 | requires: 4 | - DUK_OPT_DATAPTR16 5 | tags: 6 | - lowmemory 7 | - experimental 8 | description: > 9 | Use together with DUK_OPT_DATAPTR16 for arbitrary data pointer compression. 10 | DUK_OPT_DATAPTR_DEC16(udata,x) is a macro with a userdata and duk_uint16_t 11 | argument, and a void ptr return value. The userdata argument is the heap 12 | userdata value given at heap creation. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DDDPRINT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DDDPRINT 2 | introduced: 1.0.0 3 | requires: 4 | - DUK_OPT_DEBUG 5 | tags: 6 | - debug 7 | description: > 8 | Enable even more debug printouts. Not recommended unless you have 9 | grep handy. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DDPRINT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DDPRINT 2 | introduced: 1.0.0 3 | requires: 4 | - DUK_OPT_DEBUG 5 | tags: 6 | - debug 7 | description: > 8 | Enable more debug printouts. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DEBUG.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DEBUG 2 | introduced: 1.0.0 3 | tags: 4 | - debug 5 | description: > 6 | Enable debug code in Duktape internals. Without this option other 7 | debugging options (such as DUK_OPT_DPRINT) have no effect. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DEBUGGER_DUMPHEAP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DEBUGGER_DUMPHEAP 2 | introduced: 1.2.0 3 | requires: 4 | - DUK_OPT_DEBUGGER_SUPPORT 5 | tags: 6 | - debugger 7 | description: > 8 | Support the DumpHeap command. This is optional because the command is not 9 | always needed. The command also has a relatively large footprint (about 10 | 10% of debugger code); in absolute terms it's about 1kB of code footprint. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DEBUGGER_FWD_LOGGING.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DEBUGGER_FWD_LOGGING 2 | introduced: 1.2.0 3 | requires: 4 | - DUK_OPT_DEBUGGER_SUPPORT 5 | tags: 6 | - debugger 7 | description: > 8 | Forward log writes using the built-in logging framework to the debug client. 9 | Forwarding happens from the Duktape.Logger.prototype.info() etc calls before 10 | the raw() function is called, so that logging is forwarded even if you 11 | replace the backend. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DEBUGGER_FWD_PRINTALERT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DEBUGGER_FWD_PRINTALERT 2 | introduced: 1.2.0 3 | requires: 4 | - DUK_OPT_DEBUGGER_SUPPORT 5 | tags: 6 | - debugger 7 | description: > 8 | Forward calls to the built-in print() and alert() function to the debug 9 | client. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DEBUGGER_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DEBUGGER_SUPPORT 2 | introduced: 1.2.0 3 | requires: 4 | - DUK_OPT_INTERRUPT_COUNTER 5 | tags: 6 | - debugger 7 | description: > 8 | Enable support for Duktape debug protocol (see doc/debugger.rst) and the 9 | debug API calls (duk_debugger_attach(), duk_debugger_detach(), etc). 10 | This adds about 10kB of code footprint at the moment. 11 | 12 | This option requires DUK_OPT_INTERRUPT_COUNTER. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DEBUGGER_TRANSPORT_TORTURE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DEBUGGER_TRANSPORT_TORTURE 2 | introduced: 1.2.0 3 | requires: 4 | - DUK_OPT_DEBUGGER_SUPPORT 5 | tags: 6 | - debugger 7 | - development 8 | description: > 9 | Development time option: force debugger transport torture. Concretely this 10 | now causes Duktape to read/write debug protocol data in 1-byte increments, 11 | which stresses message parsing and transport code. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DEBUG_BUFSIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DEBUG_BUFSIZE 2 | introduced: 1.0.0 3 | requires: 4 | - DUK_OPT_DEBUG 5 | tags: 6 | - debug 7 | description: > 8 | Debug code uses a static buffer as a formatting temporary to avoid side 9 | effects in debug prints. The static buffer is large by default, which 10 | may be an issue in constrained environments. You can set the buffer size 11 | manually with this option. Example: -DDUK_OPT_DEBUG_BUFSIZE=2048. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DECLARE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DECLARE 2 | introduced: 1.0.0 3 | tags: 4 | - portability 5 | description: > 6 | Provide declarations or additional preprocessor include directives to be 7 | used when compiling Duktape. You may need this if you set 8 | DUK_OPT_PANIC_HANDLER to call your own panic handler function. You can 9 | also use this option to cause additional files to be included when compiling 10 | Duktape. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DLL_BUILD.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DLL_BUILD 2 | introduced: 1.0.0 3 | tags: 4 | - portability 5 | description: > 6 | Add this define to both Duktape and application build when Duktape is 7 | compiled as a DLL. This is especially critical on Windows: the option 8 | makes Duktape use __declspec(dllexport) and __declspec(dllimport) for 9 | public symbols. 10 | 11 | While this is not currently needed for Unix platforms, it should always 12 | be used if you build as a DLL. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DPRINT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DPRINT 2 | introduced: 1.0.0 3 | requires: 4 | - DUK_OPT_DEBUG 5 | tags: 6 | - debug 7 | description: > 8 | Enable debug printouts. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DPRINT_COLORS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DPRINT_COLORS 2 | introduced: 1.0.0 3 | tags: 4 | - debug 5 | description: > 6 | Enable coloring of debug prints with ANSI escape codes 7 | (http://en.wikipedia.org/wiki/ANSI_escape_code). The behavior is not 8 | sensitive to terminal settings. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_DPRINT_RDTSC.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_DPRINT_RDTSC 2 | introduced: 1.0.0 3 | removed: 1.4.0 4 | tags: 5 | - debug 6 | description: > 7 | Print RDTSC cycle count in debug prints if available. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_EXTERNAL_STRINGS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_EXTERNAL_STRINGS 2 | introduced: 1.1.0 3 | tags: 4 | - memory 5 | description: > 6 | Enable support for external strings. An external string requires a Duktape 7 | heap allocation to store a minimal string header, with the actual string 8 | data being held behind a pointer (similarly to how dynamic buffers work). 9 | 10 | This option is needed to use DUK_OPT_EXTSTR_INTERN_CHECK and/or 11 | DUK_OPT_EXTSTR_FREE. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_FASTINT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_FASTINT 2 | introduced: 1.2.0 3 | tags: 4 | - performance 5 | description: > 6 | Enable support for 48-bit signed "fastint" integer values. Fastints are 7 | transparent to user code (both C and ECMAScript) but may be faster than 8 | IEEE doubles on some platforms, especially those using softints. The 9 | downside of fastints is increased code footprint and a small performance 10 | penalty for some kinds of code. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_FORCE_ALIGN.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_FORCE_ALIGN 2 | introduced: 1.0.0 3 | tags: 4 | - portability 5 | description: > 6 | Use -DDUK_OPT_FORCE_ALIGN=4 or -DDUK_OPT_FORCE_ALIGN=8 to force a 7 | specific struct/value alignment instead of relying on Duktape's 8 | automatic detection. This shouldn't normally be needed. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_FUNCPTR_DEC16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_FUNCPTR_DEC16 2 | introduced: 1.1.0 3 | requires: 4 | - DUK_OPT_FUNCPTR16 5 | tags: 6 | - lowmemory 7 | - experimental 8 | description: > 9 | Use together with DUK_OPT_FUNCPTR16 for function pointer compression. 10 | DUK_OPT_FUNCPTR_DEC16(udata,x) is a macro with a userdata and duk_uint16_t 11 | argument, and a void ptr return value. The userdata argument is the heap 12 | userdata value given at heap creation. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_FUNCPTR_ENC16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_FUNCPTR_ENC16 2 | introduced: 1.1.0 3 | requires: 4 | - DUK_OPT_FUNCPTR16 5 | tags: 6 | - lowmemory 7 | - experimental 8 | description: > 9 | Use together with DUK_OPT_FUNCPTR16 for function pointer compression. 10 | DUK_OPT_FUNCPTR_ENC16(udata,p) is a macro with a userdata and void ptr 11 | argument, and a duk_uint16_t return value. The userdata arguments is the 12 | heap userdata value given at heap creation. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY 2 | introduced: 1.0.0 3 | removed: 1.0.0 4 | related: 5 | - DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY 6 | tags: 7 | - ecmascript 8 | description: > 9 | Removed, use DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY instead. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY 2 | introduced: 1.0.0 3 | removed: 1.0.0 4 | related: 5 | - DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY 6 | tags: 7 | - ecmascript 8 | description: > 9 | Removed, use DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY instead. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_GC_TORTURE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_GC_TORTURE 2 | introduced: 1.0.0 3 | tags: 4 | - gc 5 | - memory 6 | - development 7 | description: > 8 | Development time option: force full mark-and-sweep on every allocation to 9 | stress test memory management. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_HEAPPTR_DEC16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_HEAPPTR_DEC16 2 | introduced: 1.1.0 3 | requires: 4 | - DUK_OPT_HEAPPTR16 5 | tags: 6 | - lowmemory 7 | - experimental 8 | description: > 9 | Use together with DUK_OPT_HEAPPTR16 for heap pointer compression. 10 | DUK_OPT_HEAPPTR_DEC16(udata,x) is a macro with a userdata and duk_uint16_t 11 | argument, and a void ptr return value. The userdata argument is the heap 12 | userdata value given at heap creation. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_HEAPPTR_ENC16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_HEAPPTR_ENC16 2 | introduced: 1.1.0 3 | requires: 4 | - DUK_OPT_HEAPPTR16 5 | tags: 6 | - lowmemory 7 | - experimental 8 | description: > 9 | Use together with DUK_OPT_HEAPPTR16 for heap pointer compression. 10 | DUK_OPT_HEAPPTR_ENC16(udata,p) is a macro with a userdata and void ptr 11 | argument, and a duk_uint16_t return value. The userdata argument is the 12 | heap userdata value given at heap creation. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_INTERRUPT_COUNTER.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_INTERRUPT_COUNTER 2 | introduced: 1.1.0 3 | related: 4 | - DUK_OPT_DEBUGGER_SUPPORT 5 | tags: 6 | - execution 7 | - debugger 8 | description: > 9 | Enable the internal bytecode executor periodic interrupt counter. 10 | The mechanism is used to implement e.g. execution step limit, custom 11 | profiling, and debugger interaction. Enabling the interrupt counter 12 | has a small impact on execution performance. 13 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_JSON_STRINGIFY_FASTPATH.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_JSON_STRINGIFY_FASTPATH 2 | introduced: 1.3.0 3 | tags: 4 | - performance 5 | - fastpath 6 | - lowmemory 7 | description: > 8 | Enable fast apth for JSON.stringify() serialization. See 9 | DUK_USE_JSON_STRINGIFY_FASTPATH for details. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_LIGHTFUNC_BUILTINS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_LIGHTFUNC_BUILTINS 2 | introduced: 1.1.0 3 | tags: 4 | - lowmemory 5 | - experimental 6 | description: > 7 | Force built-in functions to be lightweight functions. This reduces 8 | memory footprint by around 14 kB at the cost of some non-compliant 9 | behavior. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Add a non-standard "source" property to function instances. This allows 7 | function toString() to print out the actual function source. The property 8 | is disabled by default because it increases memory footprint. 9 | 10 | NOTE: Unimplemented as of Duktape 1.2.0. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT 2 | introduced: 1.0.0 3 | removed: 1.0.0 4 | related: 5 | - DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT 6 | tags: 7 | - ecmascript 8 | description: > 9 | Removed, use DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT instead. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_AUGMENT_ERRORS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_AUGMENT_ERRORS 2 | introduced: 1.0.0 3 | related: 4 | - DUK_OPT_NO_TRACEBACKS 5 | tags: 6 | - ecmascript 7 | description: > 8 | Don't augment ECMAScript error objects with custom fields like fileName, 9 | lineNumber, and traceback data. Also disables Duktape.errCreate and 10 | Duktape.errThrow error handler callbacks. Implies DUK_OPT_NO_TRACEBACKS. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_BROWSER_LIKE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_BROWSER_LIKE 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Disable browser-like functions. Makes print() and alert() throw an error. 7 | 8 | This option is confusing when used with the Duktape command line tool, as 9 | the command like tool will immediately panic on startup. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_BUFFEROBJECT_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_BUFFEROBJECT_SUPPORT 2 | introduced: 1.3.0 3 | tags: 4 | - ecmascript6 5 | description: > 6 | Disable support for Khronos/ES6 typed arrays and Node.js Buffer objects 7 | which reduces code footprint. When disabled, Duktape custom plain buffers 8 | and Duktape.Buffer are still supported. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_BYTECODE_DUMP_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_BYTECODE_DUMP_SUPPORT 2 | introduced: 1.3.0 3 | tags: 4 | - api 5 | description: > 6 | Disable API calls to dump/load functions to bytecode (reduces code 7 | footprint). 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_COMMONJS_MODULES.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_COMMONJS_MODULES 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Disable support for CommonJS modules. Causes require() to throw an error. 7 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | - ecmascript6 6 | description: > 7 | Disable the non-standard (ES6) Object.prototype.__proto__ property 8 | which is enabled by default. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | - ecmascript6 6 | description: > 7 | Disable the non-standard (ES6) Object.setPrototypeOf method which 8 | is enabled by default. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_ES6_PROXY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_ES6_PROXY 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | - ecmascript6 6 | description: > 7 | Disable the non-standard (ES6) Proxy object which is enabled by 8 | default. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_FILE_IO.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_FILE_IO 2 | introduced: 1.0.0 3 | tags: 4 | - portability 5 | description: > 6 | Disable use of ANSI C file I/O which might be a portability issue on some 7 | platforms. Causes duk_eval_file() to throw an error, makes built-in 8 | print() and alert() no-ops, and suppresses writing of a panic 9 | message to stderr on panic. This option does not suppress debug 10 | printing so don't enable debug printing if you wish to avoid I/O. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_FUNC_STMT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_FUNC_STMT 2 | introduced: 1.0.0 3 | removed: 1.0.0 4 | related: 5 | - DUK_OPT_NO_NONSTD_FUNC_STMT 6 | tags: 7 | - ecmascript 8 | description: > 9 | Removed, use DUK_OPT_NO_NONSTD_FUNC_STMT instead. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_JC.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_JC 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Disable support for the JC format. Reduces code footprint. An attempt 7 | to encode or decode the format causes an error. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_JSONC.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_JSONC 2 | introduced: 1.0.0 3 | removed: 1.0.0 4 | related: 5 | - DUK_OPT_NO_JC 6 | tags: 7 | - ecmascript 8 | description: > 9 | Removed, use DUK_OPT_NO_JC instead. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_JSONX.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_JSONX 2 | introduced: 1.0.0 3 | removed: 1.0.0 4 | related: 5 | - DUK_OPT_NO_JX 6 | tags: 7 | - ecmascript 8 | description: > 9 | Removed, use DUK_OPT_NO_JX instead. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_JX.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_JX 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Disable support for the JX format. Reduces code footprint. An attempt 7 | to encode or decode the format causes an error. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_MS_STRINGTABLE_RESIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_MS_STRINGTABLE_RESIZE 2 | introduced: 1.0.0 3 | tags: 4 | - gc 5 | - memory 6 | description: > 7 | Disable forced string intern table resize during mark-and-sweep garbage 8 | collection. This may be useful when reference counting is disabled, as 9 | mark-and-sweep collections will be more frequent and thus more expensive. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Don't give setter/getter calls the property name being accessed as 7 | an additional, non-standard property. See 8 | http://duktape.org/guide.html#propertyvirtualization. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029 2 | introduced: 1.1.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | By default Duktape JSON.stringify() will escape U+2028 and U+2029 which 7 | is non-compliant behavior. This is the default to make JSON.stringify() 8 | output valid when embedded in a web page or parsed with eval(). This 9 | feature option enables the compliant behavior, i.e. no escaping for U+2028 10 | and U+2029. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT 2 | introduced: 1.2.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | By default Duktape String.fromCharCode() allows 32-bit codepoints which is 7 | non-compliant (the E5.1 specification has a ToUint16() coercion for the 8 | codepoints) but useful because Duktape supports non-BMP strings. This 9 | feature option restores the compliant behavior. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY 2 | introduced: 1.0.0 3 | removed: 1.0.0 4 | related: 5 | - DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY 6 | tags: 7 | - ecmascript 8 | - ecmascript6 9 | description: > 10 | Removed, use DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY instead. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF 2 | introduced: 1.0.0 3 | removed: 1.0.0 4 | related: 5 | - DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF 6 | tags: 7 | - ecmascript 8 | - ecmascript6 9 | description: > 10 | Removed, use DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF instead. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_OCTAL_SUPPORT.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_OCTAL_SUPPORT 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Disable optional octal number support (ECMAScript E5/E5.1 7 | Annex B: http://www.ecma-international.org/ecma-262/5.1/#sec-B). 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_PACKED_TVAL.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_PACKED_TVAL 2 | introduced: 1.0.0 3 | tags: 4 | - memory 5 | - portability 6 | description: > 7 | Don't use the packed 8-byte internal value representation even if otherwise 8 | possible. The packed representation has more platform/compiler portability 9 | issues than the unpacked one. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_PC2LINE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_PC2LINE 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Don't record a "pc2line" map into function instances. Without this map, 7 | exceptions won't have meaningful line numbers (virtual machine program 8 | counter values cannot be translated to line numbers) but function instances 9 | will have a smaller footprint. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_REFERENCE_COUNTING.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_REFERENCE_COUNTING 2 | introduced: 1.0.0 3 | tags: 4 | - gc 5 | - memory 6 | description: > 7 | Disable reference counting and use only mark-and-sweep for garbage 8 | collection. Although this reduces memory footprint of heap objects, the 9 | downside is much more fluctuation in memory usage. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_SECTION_B.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_SECTION_B 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Disable optional features in ECMAScript specification 7 | Annex B: http://www.ecma-international.org/ecma-262/5.1/#sec-B. 8 | Causes escape(), unescape(), and String.prototype.substr() to throw 9 | an error. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_SOURCE_NONBMP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_SOURCE_NONBMP 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Disable accurate Unicode support for non-BMP characters in source code. 7 | Non-BMP characters are then always accepted as identifier characters. 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_STRICT_DECL.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_STRICT_DECL 2 | introduced: 1.1.0 3 | tags: 4 | - ecmascript 5 | - experimental 6 | description: > 7 | Disable support for "use strict" declaration so that ECMAScript code is 8 | always executed in non-strict mode. Duktape/C functions remain strict. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_TRACEBACKS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_TRACEBACKS 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Don't record traceback data into ECMAScript error objects (but still record 7 | fileName and lineNumber). Reduces footprint and makes error handling a bit 8 | faster, at the cost of less informative ECMAScript errors. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_VERBOSE_ERRORS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_VERBOSE_ERRORS 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Don't provide error message strings or filename/line information for errors 7 | generated by Duktape. Reduces footprint, at the cost of much less 8 | informative ECMAScript errors. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_NO_ZERO_BUFFER_DATA.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_NO_ZERO_BUFFER_DATA 2 | introduced: 1.0.0 3 | tags: 4 | - memory 5 | - ecmascript 6 | description: > 7 | By default Duktape zeroes data allocated for buffer values. Define 8 | this to disable the zeroing (perhaps for performance reasons). 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_OBJSIZES16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_OBJSIZES16 2 | introduced: 1.1.0 3 | tags: 4 | - lowmemory 5 | - experimental 6 | description: > 7 | Use a 16-bit object entry and array part sizes (for low memory 8 | environments). Also automatically drops support for an object hash part 9 | to further reduce memory usage; there are rarely large objects in low 10 | memory environments simply because there's no memory to store a lot of 11 | properties. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_PANIC_HANDLER.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_PANIC_HANDLER 2 | introduced: 1.0.0 3 | tags: 4 | - portability 5 | description: > 6 | Provide a custom panic handler. 7 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_REFCOUNT16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_REFCOUNT16 2 | introduced: 1.1.0 3 | tags: 4 | - lowmemory 5 | - experimental 6 | description: > 7 | Use a 16-bit reference count field (for low memory environments). 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_SEGFAULT_ON_PANIC.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_SEGFAULT_ON_PANIC 2 | introduced: 1.0.0 3 | tags: 4 | - portability 5 | description: > 6 | Cause the default panic handler to cause a segfault instead of using 7 | abort() or exit(). This is useful when debugging with valgrind, 8 | as a segfault provides a nice C traceback in valgrind. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_SELF_TESTS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_SELF_TESTS 2 | introduced: 1.0.0 3 | tags: 4 | - debug 5 | description: > 6 | Perform run-time self tests when a Duktape heap is created. Catches 7 | platform/compiler problems which cannot be reliably detected during 8 | compile time. Not enabled by default because of the extra footprint. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_SHUFFLE_TORTURE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_SHUFFLE_TORTURE 2 | introduced: 1.2.0 3 | tags: 4 | - gc 5 | - memory 6 | - development 7 | description: > 8 | Development time option: force compiler to shuffle every possible opcode 9 | to stress shuffle behavior which is otherwise difficult to test for 10 | comprehensively. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_SIGSETJMP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_SIGSETJMP 2 | introduced: 1.1.0 3 | removed: 1.5.0 4 | tags: 5 | - portability 6 | description: > 7 | Force sigsetjmp/siglongjmp with savesigs == 0 for long control 8 | transfers (i.e. signal mask not saved/restored). See comments in 9 | DUK_OPT_SETJMP. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_STRHASH16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_STRHASH16 2 | introduced: 1.1.0 3 | tags: 4 | - lowmemory 5 | - experimental 6 | description: > 7 | Use a 16-bit string hash field (for low memory environments). 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_STRICT_UTF8_SOURCE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_STRICT_UTF8_SOURCE 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Enable strict UTF-8 parsing of source code. When enabled, non-shortest 7 | encodings (normally invalid UTF-8) and surrogate pair codepoints are 8 | accepted as valid source code characters. This option breaks compatibility 9 | with some test262 tests. 10 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_STRLEN16.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_STRLEN16 2 | introduced: 1.1.0 3 | tags: 4 | - lowmemory 5 | - experimental 6 | description: > 7 | Use a 16-bit string length field (for low memory environments). 8 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_STRTAB_CHAIN_SIZE.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_STRTAB_CHAIN_SIZE 2 | introduced: 1.1.0 3 | requires: 4 | - DUK_OPT_STRTAB_CHAIN 5 | tags: 6 | - lowmemory 7 | description: > 8 | Define stringtable size for DUK_OPT_STRTAB_CHAIN. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_TARGET_INFO.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_TARGET_INFO 2 | introduced: 1.2.0 3 | tags: 4 | - debugger 5 | description: > 6 | Define a freeform human readable string to describe the target device (e.g. 7 | "Arduino Yun"). This string will be sent as part of version/target info in 8 | the debugger protocol and shows up in the debugger UI. 9 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_TRACEBACK_DEPTH.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_TRACEBACK_DEPTH 2 | introduced: 1.0.0 3 | tags: 4 | - ecmascript 5 | description: > 6 | Override default traceback collection depth. The default is currently 10. 7 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_UNDERSCORE_SETJMP.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_UNDERSCORE_SETJMP 2 | introduced: 1.1.0 3 | removed: 1.5.0 4 | tags: 5 | - portability 6 | description: > 7 | Force _setjmp/_longjmp for long control transfers. This ensures signal 8 | mask is not saved which can be a lot faster if setjmp/longjmp saves the 9 | signal mask (this varies between platforms). See comments in 10 | DUK_OPT_SETJMP. 11 | -------------------------------------------------------------------------------- /deps/duktape/config/feature-options/DUK_OPT_USER_INITJS.yaml: -------------------------------------------------------------------------------- 1 | define: DUK_OPT_USER_INITJS 2 | introduced: 1.0.0 3 | tags: 4 | - portability 5 | description: > 6 | Provide a string to evaluate when a thread with new built-ins (a new global 7 | environment) is created. This allows you to make minor modifications to the 8 | global environment before any code is executed in it. The value must be a 9 | string, e.g.:: -DDUK_OPT_USER_INITJS='"this.foo = 123"'. 10 | 11 | Errors in the initialization code result in a fatal error. 12 | -------------------------------------------------------------------------------- /deps/duktape/config/header-snippets/64bitops.h.in: -------------------------------------------------------------------------------- 1 | /* Check whether we should use 64-bit integers or not. 2 | * 3 | * Quite incomplete now. Use 64-bit types if detected (C99 or other detection) 4 | * unless they are known to be unreliable. For instance, 64-bit types are 5 | * available on VBCC but seem to misbehave. 6 | */ 7 | #if defined(DUK_F_HAVE_64BIT) && !defined(DUK_F_VBCC) 8 | #define DUK_USE_64BIT_OPS 9 | #else 10 | #undef DUK_USE_64BIT_OPS 11 | #endif 12 | -------------------------------------------------------------------------------- /deps/duktape/config/header-snippets/architecture_fillins.h.in: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/duktape/config/header-snippets/architecture_fillins.h.in -------------------------------------------------------------------------------- /deps/duktape/config/header-snippets/cpp_exception_sanity.h.in: -------------------------------------------------------------------------------- 1 | #if defined(DUK_USE_CPP_EXCEPTIONS) && !defined(__cplusplus) 2 | #error DUK_USE_CPP_EXCEPTIONS enabled but not compiling with a C++ compiler 3 | #endif 4 | -------------------------------------------------------------------------------- /deps/duktape/config/header-snippets/inline_workaround.h.in: -------------------------------------------------------------------------------- 1 | /* Workaround for GH-323: avoid inlining control when compiling from 2 | * multiple sources, as it causes compiler portability trouble. 3 | */ 4 | #if !defined(DUK_SINGLE_FILE) 5 | #undef DUK_NOINLINE 6 | #undef DUK_INLINE 7 | #undef DUK_ALWAYS_INLINE 8 | #define DUK_NOINLINE /*nop*/ 9 | #define DUK_INLINE /*nop*/ 10 | #define DUK_ALWAYS_INLINE /*nop*/ 11 | #endif 12 | -------------------------------------------------------------------------------- /deps/duktape/config/header-snippets/platform_conditionalincludes.h.in: -------------------------------------------------------------------------------- 1 | #if defined(DUK_F_CPP) && defined(DUK_USE_CPP_EXCEPTIONS) 2 | #include /* std::exception */ 3 | #include /* std::runtime_error */ 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/header-snippets/platform_cppextras.h.in: -------------------------------------------------------------------------------- 1 | /* Workaround for older C++ compilers before including , 2 | * see e.g.: https://sourceware.org/bugzilla/show_bug.cgi?id=15366 3 | */ 4 | #if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS) 5 | #define __STDC_LIMIT_MACROS 6 | #endif 7 | #if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) 8 | #define __STDC_CONSTANT_MACROS 9 | #endif 10 | -------------------------------------------------------------------------------- /deps/duktape/config/header-snippets/reject_fast_math.h.in: -------------------------------------------------------------------------------- 1 | /* GCC/clang inaccurate math would break compliance and probably duk_tval, 2 | * so refuse to compile. Relax this if -ffast-math is tested to work. 3 | */ 4 | #if defined(__FAST_MATH__) 5 | #error __FAST_MATH__ defined, refusing to compile 6 | #endif 7 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_AIX.h.in: -------------------------------------------------------------------------------- 1 | /* AIX */ 2 | #if defined(_AIX) 3 | /* defined(__xlc__) || defined(__IBMC__): works but too wide */ 4 | #define DUK_F_AIX 5 | #endif 6 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_AMIGAOS.h.in: -------------------------------------------------------------------------------- 1 | /* AmigaOS. Neither AMIGA nor __amigaos__ is defined on VBCC, so user must 2 | * define 'AMIGA' manually when using VBCC. 3 | */ 4 | #if defined(AMIGA) || defined(__amigaos__) 5 | #define DUK_F_AMIGAOS 6 | #endif 7 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_ANDROID.h.in: -------------------------------------------------------------------------------- 1 | #if defined(ANDROID) || defined(__ANDROID__) 2 | #define DUK_F_ANDROID 3 | #endif 4 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_APPLE.h.in: -------------------------------------------------------------------------------- 1 | /* Apple OSX, iOS */ 2 | #if defined(__APPLE__) 3 | #define DUK_F_APPLE 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_ARM.h.in: -------------------------------------------------------------------------------- 1 | /* ARM */ 2 | #if defined(__arm__) || defined(__thumb__) || defined(_ARM) || defined(_M_ARM) || defined(_M_ARM64) || defined(__aarch64__) 3 | #define DUK_F_ARM 4 | #if defined(__LP64__) || defined(_LP64) || defined(__arm64) || defined(__arm64__) || defined(_M_ARM64) || defined(__aarch64__) 5 | #define DUK_F_ARM64 6 | #else 7 | #define DUK_F_ARM32 8 | #endif 9 | #endif 10 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_BCC.h.in: -------------------------------------------------------------------------------- 1 | /* BCC (Bruce's C compiler): this is a "torture target" for compilation */ 2 | #if defined(__BCC__) || defined(__BCC_VERSION__) 3 | #define DUK_F_BCC 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_BSD.h.in: -------------------------------------------------------------------------------- 1 | /* BSD variant */ 2 | #if defined(DUK_F_FREEBSD) || defined(DUK_F_NETBSD) || defined(DUK_F_OPENBSD) || \ 3 | defined(__bsdi__) || defined(__DragonFly__) 4 | #define DUK_F_BSD 5 | #endif 6 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_C99.h.in: -------------------------------------------------------------------------------- 1 | /* C99 or above */ 2 | #undef DUK_F_C99 3 | #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) 4 | #define DUK_F_C99 5 | #endif 6 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_CLANG.h.in: -------------------------------------------------------------------------------- 1 | /* Clang */ 2 | #if defined(__clang__) 3 | #define DUK_F_CLANG 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_CPP.h.in: -------------------------------------------------------------------------------- 1 | /* C++ */ 2 | #undef DUK_F_CPP 3 | #if defined(__cplusplus) 4 | #define DUK_F_CPP 5 | #endif 6 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_CPP11.h.in: -------------------------------------------------------------------------------- 1 | /* C++11 or above */ 2 | #undef DUK_F_CPP11 3 | #if defined(__cplusplus) && (__cplusplus >= 201103L) 4 | #define DUK_F_CPP11 5 | #endif 6 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_CYGWIN.h.in: -------------------------------------------------------------------------------- 1 | /* Cygwin */ 2 | #if defined(__CYGWIN__) 3 | #define DUK_F_CYGWIN 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_DURANGO.h.in: -------------------------------------------------------------------------------- 1 | /* Durango (Xbox One) */ 2 | #if defined(_DURANGO) || defined(_XBOX_ONE) 3 | #define DUK_F_DURANGO 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_EMSCRIPTEN.h.in: -------------------------------------------------------------------------------- 1 | /* Emscripten (provided explicitly by user), improve if possible */ 2 | #if defined(EMSCRIPTEN) 3 | #define DUK_F_EMSCRIPTEN 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_FLASHPLAYER.h.in: -------------------------------------------------------------------------------- 1 | /* Flash player (e.g. Crossbridge) */ 2 | #if defined(__FLASHPLAYER__) 3 | #define DUK_F_FLASHPLAYER 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_FREEBSD.h.in: -------------------------------------------------------------------------------- 1 | /* FreeBSD */ 2 | #if defined(__FreeBSD__) || defined(__FreeBSD) 3 | #define DUK_F_FREEBSD 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_HPUX.h.in: -------------------------------------------------------------------------------- 1 | /* HPUX */ 2 | #if defined(__hpux) 3 | #define DUK_F_HPUX 4 | #if defined(__ia64) 5 | #define DUK_F_HPUX_ITANIUM 6 | #endif 7 | #endif 8 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_LINUX.h.in: -------------------------------------------------------------------------------- 1 | /* Linux */ 2 | #if defined(__linux) || defined(__linux__) || defined(linux) 3 | #define DUK_F_LINUX 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_M68K.h.in: -------------------------------------------------------------------------------- 1 | /* Motorola 68K. Not defined by VBCC, so user must define one of these 2 | * manually when using VBCC. 3 | */ 4 | #if defined(__m68k__) || defined(M68000) || defined(__MC68K__) 5 | #define DUK_F_M68K 6 | #endif 7 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_MINGW.h.in: -------------------------------------------------------------------------------- 1 | /* MinGW. Also GCC flags (DUK_F_GCC) are enabled now. */ 2 | #if defined(__MINGW32__) || defined(__MINGW64__) 3 | #define DUK_F_MINGW 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_MINT.h.in: -------------------------------------------------------------------------------- 1 | /* Atari Mint */ 2 | #if defined(__MINT__) 3 | #define DUK_F_MINT 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_NETBSD.h.in: -------------------------------------------------------------------------------- 1 | /* NetBSD */ 2 | #if defined(__NetBSD__) || defined(__NetBSD) 3 | #define DUK_F_NETBSD 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_NO_STDINT_H.h.in: -------------------------------------------------------------------------------- 1 | /* stdint.h not available */ 2 | #if defined(DUK_F_WINDOWS) && defined(_MSC_VER) 3 | #if (_MSC_VER < 1700) 4 | /* VS2012+ has stdint.h, < VS2012 does not (but it's available for download). */ 5 | #define DUK_F_NO_STDINT_H 6 | #endif 7 | #endif 8 | #if !defined(DUK_F_NO_STDINT_H) && (defined(DUK_F_TOS) || defined(DUK_F_BCC)) 9 | #define DUK_F_NO_STDINT_H 10 | #endif 11 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_OPENBSD.h.in: -------------------------------------------------------------------------------- 1 | /* OpenBSD */ 2 | #if defined(__OpenBSD__) || defined(__OpenBSD) 3 | #define DUK_F_OPENBSD 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_ORBIS.h.in: -------------------------------------------------------------------------------- 1 | /* Orbis (PS4) variant */ 2 | #if defined(DUK_F_FREEBSD) && defined(__ORBIS__) 3 | #define DUK_F_ORBIS 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_POSIX.h.in: -------------------------------------------------------------------------------- 1 | /* POSIX */ 2 | #if defined(__posix) 3 | #define DUK_F_POSIX 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_PPC.h.in: -------------------------------------------------------------------------------- 1 | /* PowerPC */ 2 | #if defined(__powerpc) || defined(__powerpc__) || defined(__PPC__) 3 | #define DUK_F_PPC 4 | #if defined(__PPC64__) || defined(__LP64__) || defined(_LP64) 5 | #define DUK_F_PPC64 6 | #else 7 | #define DUK_F_PPC32 8 | #endif 9 | #endif 10 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_QNX.h.in: -------------------------------------------------------------------------------- 1 | /* QNX */ 2 | #if defined(__QNX__) 3 | #define DUK_F_QNX 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_RISCV.h.in: -------------------------------------------------------------------------------- 1 | /* RISC-V, https://github.com/riscv/riscv-toolchain-conventions#cc-preprocessor-definitions */ 2 | #if defined(__riscv) 3 | #define DUK_F_RISCV 4 | #if defined(__riscv_xlen) 5 | #if (__riscv_xlen == 32) 6 | #define DUK_F_RISCV32 7 | #elif (__riscv_xlen == 64) 8 | #define DUK_F_RISCV64 9 | #else 10 | #error __riscv_xlen has unsupported value (not 32 or 64) 11 | #endif 12 | #else 13 | #error __riscv defined without __riscv_xlen 14 | #endif 15 | #endif /* __riscv */ 16 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_SPARC.h.in: -------------------------------------------------------------------------------- 1 | /* SPARC */ 2 | #if defined(sparc) || defined(__sparc) || defined(__sparc__) 3 | #define DUK_F_SPARC 4 | #if defined(__LP64__) || defined(_LP64) 5 | #define DUK_F_SPARC64 6 | #else 7 | #define DUK_F_SPARC32 8 | #endif 9 | #endif 10 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_SUN.h.in: -------------------------------------------------------------------------------- 1 | /* illumos / Solaris */ 2 | #if defined(__sun) && defined(__SVR4) 3 | #define DUK_F_SUN 4 | #if defined(__SUNPRO_C) && (__SUNPRO_C < 0x550) 5 | #define DUK_F_OLD_SOLARIS 6 | /* Defines _ILP32 / _LP64 required by DUK_F_X86/DUK_F_X64. Platforms 7 | * are processed before architectures, so this happens before the 8 | * DUK_F_X86/DUK_F_X64 detection is emitted. 9 | */ 10 | #include 11 | #endif 12 | #endif 13 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_SUPERH.h.in: -------------------------------------------------------------------------------- 1 | /* SuperH */ 2 | #if defined(__sh__) || \ 3 | defined(__sh1__) || defined(__SH1__) || \ 4 | defined(__sh2__) || defined(__SH2__) || \ 5 | defined(__sh3__) || defined(__SH3__) || \ 6 | defined(__sh4__) || defined(__SH4__) || \ 7 | defined(__sh5__) || defined(__SH5__) 8 | #define DUK_F_SUPERH 9 | #endif 10 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_TINSPIRE.h.in: -------------------------------------------------------------------------------- 1 | /* TI-Nspire (using Ndless) */ 2 | #if defined(_TINSPIRE) 3 | #define DUK_F_TINSPIRE 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_TINYC.h.in: -------------------------------------------------------------------------------- 1 | /* TinyC */ 2 | #if defined(__TINYC__) 3 | /* http://bellard.org/tcc/tcc-doc.html#SEC9 */ 4 | #define DUK_F_TINYC 5 | #endif 6 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_TOS.h.in: -------------------------------------------------------------------------------- 1 | /* Atari ST TOS. __TOS__ defined by PureC. No platform define in VBCC 2 | * apparently, so to use with VBCC user must define __TOS__ manually. 3 | */ 4 | #if defined(__TOS__) 5 | #define DUK_F_TOS 6 | #endif 7 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_UCLIBC.h.in: -------------------------------------------------------------------------------- 1 | /* uclibc */ 2 | #if defined(__UCLIBC__) 3 | #define DUK_F_UCLIBC 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_ULL_CONSTS.h.in: -------------------------------------------------------------------------------- 1 | /* ULL / LL preprocessor constants should be avoided because they're not 2 | * always available. With suitable options, some compilers will support 3 | * 64-bit integer types but won't support ULL / LL preprocessor constants. 4 | * Assume C99/C++11 environments have these. However, BCC is nominally 5 | * C99 but doesn't support these constants. 6 | */ 7 | #if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && !defined(DUK_F_BCC) 8 | #define DUK_F_ULL_CONSTS 9 | #endif 10 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_UNIX.h.in: -------------------------------------------------------------------------------- 1 | /* Generic Unix (includes Cygwin) */ 2 | #if defined(__unix) || defined(__unix__) || defined(unix) || \ 3 | defined(DUK_F_LINUX) || defined(DUK_F_BSD) 4 | #define DUK_F_UNIX 5 | #endif 6 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_VBCC.h.in: -------------------------------------------------------------------------------- 1 | /* VBCC */ 2 | #if defined(__VBCC__) 3 | #define DUK_F_VBCC 4 | #endif 5 | -------------------------------------------------------------------------------- /deps/duktape/config/helper-snippets/DUK_F_WINDOWS.h.in: -------------------------------------------------------------------------------- 1 | /* Windows, both 32-bit and 64-bit */ 2 | #if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64) || \ 3 | defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) 4 | #define DUK_F_WINDOWS 5 | #if defined(_WIN64) || defined(WIN64) 6 | #define DUK_F_WIN64 7 | #else 8 | #define DUK_F_WIN32 9 | #endif 10 | #endif 11 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_aix.h.in: -------------------------------------------------------------------------------- 1 | #if !defined(DUK_USE_BYTEORDER) 2 | #define DUK_USE_BYTEORDER 3 3 | #endif 4 | #define DUK_USE_DATE_NOW_GETTIMEOFDAY 5 | #define DUK_USE_DATE_TZO_GMTIME_R 6 | #define DUK_USE_DATE_PRS_STRPTIME 7 | #define DUK_USE_DATE_FMT_STRFTIME 8 | #include 9 | #include 10 | #include 11 | 12 | #define DUK_USE_OS_STRING "aix" 13 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_cygwin.h.in: -------------------------------------------------------------------------------- 1 | /* don't use strptime() for now */ 2 | #define DUK_USE_DATE_NOW_GETTIMEOFDAY 3 | #define DUK_USE_DATE_TZO_GMTIME_R 4 | #define DUK_USE_DATE_FMT_STRFTIME 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #define DUK_JMPBUF_TYPE jmp_buf 12 | #define DUK_SETJMP(jb) _setjmp((jb)) 13 | #define DUK_LONGJMP(jb) _longjmp((jb), 1) 14 | 15 | #define DUK_USE_OS_STRING "windows" 16 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_flashplayer.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_DATE_NOW_GETTIMEOFDAY 2 | #define DUK_USE_DATE_TZO_GMTIME_R 3 | #define DUK_USE_DATE_PRS_STRPTIME 4 | #define DUK_USE_DATE_FMT_STRFTIME 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #define DUK_USE_OS_STRING "flashplayer" 11 | 12 | #if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_FLASHPLAYER) 13 | #define DUK_USE_BYTEORDER 1 14 | #endif 15 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_genericbsd.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_DATE_NOW_GETTIMEOFDAY 2 | #define DUK_USE_DATE_TZO_GMTIME_R 3 | #define DUK_USE_DATE_PRS_STRPTIME 4 | #define DUK_USE_DATE_FMT_STRFTIME 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #define DUK_USE_OS_STRING "bsd" 12 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_genericunix.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_DATE_NOW_GETTIMEOFDAY 2 | #define DUK_USE_DATE_TZO_GMTIME_R 3 | #define DUK_USE_DATE_PRS_STRPTIME 4 | #define DUK_USE_DATE_FMT_STRFTIME 5 | #include 6 | #include 7 | #define DUK_USE_OS_STRING "unknown" 8 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_hpux.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_F_NO_STDINT_H 2 | #if !defined(DUK_USE_BYTEORDER) 3 | #define DUK_USE_BYTEORDER 3 4 | #endif 5 | #define DUK_USE_DATE_NOW_GETTIMEOFDAY 6 | #define DUK_USE_DATE_TZO_GMTIME_R 7 | #define DUK_USE_DATE_PRS_STRPTIME 8 | #define DUK_USE_DATE_FMT_STRFTIME 9 | #include 10 | #include 11 | #include 12 | 13 | #define DUK_USE_OS_STRING "hpux" 14 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_openbsd.h.in: -------------------------------------------------------------------------------- 1 | /* http://www.monkey.org/openbsd/archive/ports/0401/msg00089.html */ 2 | #define DUK_USE_DATE_NOW_GETTIMEOFDAY 3 | #define DUK_USE_DATE_TZO_GMTIME_R 4 | #define DUK_USE_DATE_PRS_STRPTIME 5 | #define DUK_USE_DATE_FMT_STRFTIME 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #define DUK_USE_OS_STRING "openbsd" 13 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_orbis.h.in: -------------------------------------------------------------------------------- 1 | /* Orbis = PS4 */ 2 | #define DUK_USE_DATE_NOW_GETTIMEOFDAY 3 | #define DUK_USE_DATE_TZO_GMTIME_S 4 | /* no parsing (not an error) */ 5 | #define DUK_USE_DATE_FMT_STRFTIME 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #define DUK_USE_OS_STRING "orbis" 13 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_posix.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_DATE_NOW_GETTIMEOFDAY 2 | #define DUK_USE_DATE_TZO_GMTIME_R 3 | #define DUK_USE_DATE_PRS_STRPTIME 4 | #define DUK_USE_DATE_FMT_STRFTIME 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | #define DUK_USE_OS_STRING "posix" 12 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_tinspire.h.in: -------------------------------------------------------------------------------- 1 | #if defined(DUK_COMPILING_DUKTAPE) && !defined(_XOPEN_SOURCE) 2 | #define _XOPEN_SOURCE /* e.g. strptime */ 3 | #endif 4 | 5 | #define DUK_USE_DATE_NOW_GETTIMEOFDAY 6 | #define DUK_USE_DATE_TZO_GMTIME_R 7 | #define DUK_USE_DATE_PRS_STRPTIME 8 | #define DUK_USE_DATE_FMT_STRFTIME 9 | #include 10 | #include 11 | #include 12 | #include 13 | 14 | #define DUK_USE_OS_STRING "tinspire" 15 | -------------------------------------------------------------------------------- /deps/duktape/config/platforms/platform_tos.h.in: -------------------------------------------------------------------------------- 1 | #define DUK_USE_DATE_NOW_TIME 2 | #define DUK_USE_DATE_TZO_GMTIME 3 | /* no parsing (not an error) */ 4 | #define DUK_USE_DATE_FMT_STRFTIME 5 | #include 6 | 7 | #define DUK_USE_OS_STRING "tos" 8 | 9 | /* TOS on M68K is always big endian. */ 10 | #if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_M68K) 11 | #define DUK_USE_BYTEORDER 3 12 | #endif 13 | -------------------------------------------------------------------------------- /deps/duktape/debugger/duk_debugerrors.yaml: -------------------------------------------------------------------------------- 1 | error_codes: 2 | - Unknown 3 | - UnsupportedCommand 4 | - TooMany 5 | - NotFound 6 | - ApplicationError 7 | -------------------------------------------------------------------------------- /deps/duktape/duk_dist_meta.json: -------------------------------------------------------------------------------- 1 | { 2 | "comment": "Metadata for Duktape distributable", 3 | "duk_version_string": "2.6.0", 4 | "type": "duk_dist_meta", 5 | "duk_version": 20600, 6 | "git_branch": "v2-maintenance", 7 | "git_commit": "fffa346eff06a8764b02c31d4336f63a773a95c3", 8 | "git_describe": "v2.6.0" 9 | } -------------------------------------------------------------------------------- /deps/duktape/examples/README.rst: -------------------------------------------------------------------------------- 1 | ================ 2 | Duktape examples 3 | ================ 4 | 5 | Examples for using Duktape. These support user documentation and are 6 | intended as informative illustrations only. 7 | 8 | Examples are unmaintained and are not production quality code. Bugs are 9 | not necessarily fixed, unless the bug makes the example misleading as 10 | documentation. 11 | -------------------------------------------------------------------------------- /deps/duktape/examples/alloc-hybrid/README.rst: -------------------------------------------------------------------------------- 1 | ===================== 2 | Hybrid pool allocator 3 | ===================== 4 | 5 | Example allocator that tries to satisfy memory allocations for small sizes 6 | from a set of fixed pools, but always falls back to malloc/realloc/free if 7 | a larger size is requested or the pools have been exhausted. 8 | 9 | This may be useful to reduce memory churn when the platform allocator does 10 | not handle allocations for a lot of small memory areas efficiently. 11 | -------------------------------------------------------------------------------- /deps/duktape/examples/alloc-hybrid/duk_alloc_hybrid.h: -------------------------------------------------------------------------------- 1 | #if !defined(DUK_ALLOC_HYBRID_H_INCLUDED) 2 | #define DUK_ALLOC_HYBRID_H_INCLUDED 3 | 4 | #include "duktape.h" 5 | 6 | void *duk_alloc_hybrid_init(void); 7 | void *duk_alloc_hybrid(void *udata, duk_size_t size); 8 | void *duk_realloc_hybrid(void *udata, void *ptr, duk_size_t size); 9 | void duk_free_hybrid(void *udata, void *ptr); 10 | 11 | #endif /* DUK_ALLOC_HYBRID_H_INCLUDED */ 12 | -------------------------------------------------------------------------------- /deps/duktape/examples/alloc-logging/README.rst: -------------------------------------------------------------------------------- 1 | ====================== 2 | Allocator with logging 3 | ====================== 4 | 5 | Example allocator that writes all memory alloc/realloc/free calls into a 6 | log file so that memory usage can replayed later. This is useful to e.g. 7 | optimize pool sizes. 8 | -------------------------------------------------------------------------------- /deps/duktape/examples/alloc-logging/duk_alloc_logging.h: -------------------------------------------------------------------------------- 1 | #if !defined(DUK_ALLOC_LOGGING_H_INCLUDED) 2 | #define DUK_ALLOC_LOGGING_H_INCLUDED 3 | 4 | #include "duktape.h" 5 | 6 | void *duk_alloc_logging(void *udata, duk_size_t size); 7 | void *duk_realloc_logging(void *udata, void *ptr, duk_size_t size); 8 | void duk_free_logging(void *udata, void *ptr); 9 | 10 | #endif /* DUK_ALLOC_LOGGING_H_INCLUDED */ 11 | -------------------------------------------------------------------------------- /deps/duktape/examples/alloc-torture/README.rst: -------------------------------------------------------------------------------- 1 | ========================================== 2 | Allocator with memory wiping and red zones 3 | ========================================== 4 | 5 | Example allocator that wipes memory on free and checks that no out-of-bounds 6 | writes have been made to bytes just before and after the allocated area. 7 | 8 | Valgrind is a better tool for detecting these memory issues, but it's not 9 | available for all targets so you can use something like this to detect 10 | memory lifecycle or out-of-bounds issues. 11 | -------------------------------------------------------------------------------- /deps/duktape/examples/alloc-torture/duk_alloc_torture.h: -------------------------------------------------------------------------------- 1 | #if !defined(DUK_ALLOC_TORTURE_H_INCLUDED) 2 | #define DUK_ALLOC_TORTURE_H_INCLUDED 3 | 4 | #include "duktape.h" 5 | 6 | void *duk_alloc_torture(void *udata, duk_size_t size); 7 | void *duk_realloc_torture(void *udata, void *ptr, duk_size_t size); 8 | void duk_free_torture(void *udata, void *ptr); 9 | 10 | #endif /* DUK_ALLOC_TORTURE_H_INCLUDED */ 11 | -------------------------------------------------------------------------------- /deps/duktape/examples/cmdline/README.rst: -------------------------------------------------------------------------------- 1 | ==================== 2 | Duktape command line 3 | ==================== 4 | 5 | ECMAScript command line execution tool, useful for running ECMAScript code 6 | from a file, stdin, or interactively. Also used by automatic testing. 7 | -------------------------------------------------------------------------------- /deps/duktape/examples/codepage-conv/README.rst: -------------------------------------------------------------------------------- 1 | Codepage conversion example 2 | =========================== 3 | 4 | Example of how to convert an 8-bit input string (e.g. ISO-8859-1 or Windows 5 | codepage 1252) into CESU-8 without using an external library like iconv. 6 | 7 | This is useful e.g. when compiling non-UTF-8 source code which cannot be 8 | converted to UTF-8 (CESU-8) at build time. 9 | -------------------------------------------------------------------------------- /deps/duktape/examples/codepage-conv/duk_codepage_conv.h: -------------------------------------------------------------------------------- 1 | #if !defined(DUK_CODEPAGE_CONV_H_INCLUDED) 2 | #define DUK_CODEPAGE_CONV_H_INCLUDED 3 | 4 | #include "duktape.h" 5 | 6 | void duk_decode_string_codepage(duk_context *ctx, const char *str, size_t len, unsigned int *codepage); 7 | 8 | #endif /* DUK_CODEPAGE_CONV_H_INCLUDED */ 9 | -------------------------------------------------------------------------------- /deps/duktape/examples/coffee/README.rst: -------------------------------------------------------------------------------- 1 | ===================== 2 | Coffeescript examples 3 | ===================== 4 | 5 | A few tests to see how CoffeeScript works with Duktape. Just convert the 6 | Coffeescript files to Javascript with the ``Makefile.coffee`` in the 7 | distributable, or manually:: 8 | 9 | $ coffee -c hello.coffee 10 | $ cat hello.js 11 | -------------------------------------------------------------------------------- /deps/duktape/examples/coffee/globals.coffee: -------------------------------------------------------------------------------- 1 | 2 | print '*** All globals' 3 | print(name) for name in Object.getOwnPropertyNames(this) 4 | 5 | print '*** Globals with a short name (<= 8 chars)' 6 | print(name) for name in Object.getOwnPropertyNames(this) when name.length <= 8 7 | 8 | -------------------------------------------------------------------------------- /deps/duktape/examples/coffee/hello.coffee: -------------------------------------------------------------------------------- 1 | print 'Hello world!' 2 | print 'version: ' + Duktape.version 3 | -------------------------------------------------------------------------------- /deps/duktape/examples/debug-trans-dvalue/README.rst: -------------------------------------------------------------------------------- 1 | =========================================================== 2 | Debug transport with local debug protocol encoding/decoding 3 | =========================================================== 4 | 5 | This example implements a debug transport which decodes/encodes the Duktape 6 | debug protocol locally into a more easy to use C interface, which is useful 7 | for debug clients implemented locally on the target. The example also 8 | demonstrates how to trial parse dvalues in C. 9 | -------------------------------------------------------------------------------- /deps/duktape/examples/dummy-date-provider/README.rst: -------------------------------------------------------------------------------- 1 | ==================================== 2 | Dummy external Date provider example 3 | ==================================== 4 | 5 | This example implements a dummy, minimal external Date provider. 6 | -------------------------------------------------------------------------------- /deps/duktape/examples/eval/README.rst: -------------------------------------------------------------------------------- 1 | ============ 2 | Eval example 3 | ============ 4 | 5 | Evaluate expressions from command line. 6 | -------------------------------------------------------------------------------- /deps/duktape/examples/eventloop/basic-test.js: -------------------------------------------------------------------------------- 1 | /* 2 | * A few basic tests 3 | */ 4 | 5 | var count = 0; 6 | var intervalId; 7 | 8 | setTimeout(function (x) { print('timer 1', x); }, 1234, 'foo'); 9 | setTimeout('print("timer 2");', 4321); 10 | setTimeout(function () { print('timer 3'); }, 2345); 11 | intervalId = setInterval(function (x, y) { 12 | print('interval', ++count, x, y); 13 | if (count >= 10) { 14 | clearInterval(intervalId); 15 | } 16 | }, 400, 'foo', 'bar'); 17 | -------------------------------------------------------------------------------- /deps/duktape/examples/eventloop/c_eventloop.h: -------------------------------------------------------------------------------- 1 | #if !defined(C_EVENTLOOP_H) 2 | #define C_EVENTLOOP_H 3 | 4 | void eventloop_register(duk_context *ctx); 5 | duk_ret_t eventloop_run(duk_context *ctx, void *udata); 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /deps/duktape/examples/guide/README.rst: -------------------------------------------------------------------------------- 1 | =========================== 2 | Duktape guide example files 3 | =========================== 4 | 5 | Examples used in the Duktape guide. 6 | -------------------------------------------------------------------------------- /deps/duktape/examples/guide/fib.js: -------------------------------------------------------------------------------- 1 | // fib.js 2 | function fib(n) { 3 | if (n == 0) { return 0; } 4 | if (n == 1) { return 1; } 5 | return fib(n-1) + fib(n-2); 6 | } 7 | 8 | function test() { 9 | var res = []; 10 | for (i = 0; i < 20; i++) { 11 | res.push(fib(i)); 12 | } 13 | print(res.join(' ')); 14 | } 15 | 16 | test(); 17 | -------------------------------------------------------------------------------- /deps/duktape/examples/guide/process.js: -------------------------------------------------------------------------------- 1 | // process.js 2 | function processLine(line) { 3 | return line.trim() 4 | .replace(/[<>&"'\u0000-\u001F\u007E-\uFFFF]/g, function(x) { 5 | // escape HTML characters 6 | return '&#' + x.charCodeAt(0) + ';' 7 | }) 8 | .replace(/\*(.*?)\*/g, function(x, m) { 9 | // automatically bold text between stars 10 | return '' + m + ''; 11 | }); 12 | } 13 | -------------------------------------------------------------------------------- /deps/duktape/examples/hello/README.rst: -------------------------------------------------------------------------------- 1 | =================== 2 | Hello world example 3 | =================== 4 | 5 | Very simple example, most useful for compilation tests. 6 | -------------------------------------------------------------------------------- /deps/duktape/examples/jxpretty/README.rst: -------------------------------------------------------------------------------- 1 | ================ 2 | Jxpretty example 3 | ================ 4 | 5 | Simple command line utility to pretty print JSON in the JX format. 6 | -------------------------------------------------------------------------------- /deps/duktape/examples/sandbox/README.rst: -------------------------------------------------------------------------------- 1 | =============== 2 | Sandbox example 3 | =============== 4 | 5 | Very simple, minimal sandboxing example. 6 | -------------------------------------------------------------------------------- /deps/duktape/extras/alloc-pool/ptrcomp_fixup.h: -------------------------------------------------------------------------------- 1 | /* To provide declarations for inline pointer compression functions. */ 2 | #include "duk_alloc_pool.h" 3 | -------------------------------------------------------------------------------- /deps/duktape/extras/duk-v1-compat/Makefile: -------------------------------------------------------------------------------- 1 | # For manual testing; say 'make' in extras/duk-v1-compat and run ./test. 2 | 3 | CC = gcc 4 | 5 | .PHONY: test 6 | test: 7 | -rm -rf ./prep 8 | python2 ../../tools/configure.py --quiet --output-directory ./prep 9 | $(CC) -std=c99 -Wall -Wextra -o $@ -I./prep -I. ./prep/duktape.c duk_v1_compat.c test.c -lm 10 | ./test 11 | 12 | .PHONY: clean 13 | clean: 14 | -rm -rf ./prep 15 | -rm -f test 16 | -------------------------------------------------------------------------------- /deps/duktape/extras/duk-v1-compat/test_compile1.js: -------------------------------------------------------------------------------- 1 | // File to compile, no error 2 | print('Hello from test_compile1.js'); 3 | print(new Error('test error for traceback (shows filename)').stack); 4 | -------------------------------------------------------------------------------- /deps/duktape/extras/duk-v1-compat/test_compile2.js: -------------------------------------------------------------------------------- 1 | // File to compile, syntax error 2 | print('Hello from test_compile2.js'); 3 | = y +; 4 | -------------------------------------------------------------------------------- /deps/duktape/extras/duk-v1-compat/test_eval1.js: -------------------------------------------------------------------------------- 1 | // File to eval, no error 2 | print('Hello from test_eval1.js'); 3 | print(new Error('test error for traceback (shows filename)').stack); 4 | 123; 5 | -------------------------------------------------------------------------------- /deps/duktape/extras/duk-v1-compat/test_eval2.js: -------------------------------------------------------------------------------- 1 | // File to eval, throws error 2 | print('Hello from test_eval2.js'); 3 | print(new Error('test error for traceback (shows filename)').stack); 4 | throw new Error('aiee'); 5 | -------------------------------------------------------------------------------- /deps/duktape/extras/minimal-printf/Makefile: -------------------------------------------------------------------------------- 1 | # Just for manual testing 2 | CC = gcc 3 | 4 | .PHONY: test 5 | test: duk_minimal_printf.c 6 | $(CC) -std=c99 -Wall -Wextra -fno-stack-protector -m32 -Os -fomit-frame-pointer -otest duk_minimal_printf.c test.c 7 | ./test 8 | -------------------------------------------------------------------------------- /deps/duktape/extras/module-node/duk_module_node.h: -------------------------------------------------------------------------------- 1 | #if !defined(DUK_MODULE_NODE_H_INCLUDED) 2 | #define DUK_MODULE_NODE_H_INCLUDED 3 | 4 | #include "duktape.h" 5 | 6 | #if defined(__cplusplus) 7 | extern "C" { 8 | #endif 9 | 10 | extern duk_ret_t duk_module_node_peval_main(duk_context *ctx, const char *path); 11 | extern void duk_module_node_init(duk_context *ctx); 12 | 13 | #if defined(__cplusplus) 14 | } 15 | #endif /* end 'extern "C"' wrapper */ 16 | 17 | #endif /* DUK_MODULE_NODE_H_INCLUDED */ 18 | -------------------------------------------------------------------------------- /deps/duktape/extras/print-alert/Makefile: -------------------------------------------------------------------------------- 1 | # For manual testing; say 'make' in extras/print-alert and run ./test. 2 | 3 | CC = gcc 4 | 5 | .PHONY: test 6 | test: 7 | -rm -rf ./prep 8 | python2 ../../tools/configure.py --quiet --output-directory ./prep 9 | $(CC) -std=c99 -Wall -Wextra -otest -I./prep ./prep/duktape.c duk_print_alert.c test.c -lm 10 | ./test 'print("foo", "bar", 1, 2, 3)' 11 | ./test 'alert("foo", "bar", 1, 2, 3)' 12 | 13 | .PHONY: clean 14 | clean: 15 | -rm -rf ./prep 16 | -rm -f test 17 | -------------------------------------------------------------------------------- /deps/duktape/extras/print-alert/duk_print_alert.h: -------------------------------------------------------------------------------- 1 | #if !defined(DUK_PRINT_ALERT_H_INCLUDED) 2 | #define DUK_PRINT_ALERT_H_INCLUDED 3 | 4 | #include "duktape.h" 5 | 6 | #if defined(__cplusplus) 7 | extern "C" { 8 | #endif 9 | 10 | /* No flags at the moment. */ 11 | 12 | extern void duk_print_alert_init(duk_context *ctx, duk_uint_t flags); 13 | 14 | #if defined(__cplusplus) 15 | } 16 | #endif /* end 'extern "C"' wrapper */ 17 | 18 | #endif /* DUK_PRINT_ALERT_H_INCLUDED */ 19 | -------------------------------------------------------------------------------- /deps/duktape/licenses/commonjs.txt: -------------------------------------------------------------------------------- 1 | CommonJS specification snapshots are included in the references/ 2 | directory. CommonJS is under the MIT license: http://www.commonjs.org/. 3 | -------------------------------------------------------------------------------- /deps/duktape/licenses/lua.txt: -------------------------------------------------------------------------------- 1 | Lua is under the MIT license: http://www.lua.org/license.html. 2 | -------------------------------------------------------------------------------- /deps/duktape/licenses/splitmix64.txt: -------------------------------------------------------------------------------- 1 | /* Written in 2015 by Sebastiano Vigna (vigna@acm.org) 2 | 3 | To the extent possible under law, the author has dedicated all copyright 4 | and related and neighboring rights to this software to the public domain 5 | worldwide. This software is distributed without any warranty. 6 | 7 | See . */ 8 | -------------------------------------------------------------------------------- /deps/duktape/licenses/xoroshiro128plus.txt: -------------------------------------------------------------------------------- 1 | /* Written in 2016 by David Blackman and Sebastiano Vigna (vigna@acm.org) 2 | 3 | To the extent possible under law, the author has dedicated all copyright 4 | and related and neighboring rights to this software to the public domain 5 | worldwide. This software is distributed without any warranty. 6 | 7 | See . */ 8 | -------------------------------------------------------------------------------- /deps/duktape/polyfills/global.js: -------------------------------------------------------------------------------- 1 | /* 2 | * Duktape 2.5.0 adds a 'globalThis' binding. Polyfill for earlier versions. 3 | */ 4 | 5 | if (typeof globalThis === 'undefined') { 6 | (function () { 7 | var global = new Function('return this;')(); 8 | Object.defineProperty(global, 'globalThis', { 9 | value: global, 10 | writable: true, 11 | enumerable: false, 12 | configurable: true 13 | }); 14 | })(); 15 | } 16 | -------------------------------------------------------------------------------- /deps/duktape/polyfills/object-prototype-definegetter.js: -------------------------------------------------------------------------------- 1 | /* 2 | * Object.prototype.__defineGetter__ polyfill 3 | */ 4 | 5 | (function () { 6 | if (typeof Object.prototype.__defineGetter__ === 'undefined') { 7 | var DP = Object.defineProperty; 8 | DP(Object.prototype, '__defineGetter__', { 9 | value: function (n, f) { 10 | DP(this, n, { enumerable: true, configurable: true, get: f }); 11 | }, writable: true, enumerable: false, configurable: true 12 | }); 13 | } 14 | })(); 15 | -------------------------------------------------------------------------------- /deps/duktape/polyfills/object-prototype-definesetter.js: -------------------------------------------------------------------------------- 1 | /* 2 | * Object.prototype.__defineSetter__ polyfill 3 | */ 4 | 5 | (function () { 6 | if (typeof Object.prototype.__defineSetter__ === 'undefined') { 7 | var DP = Object.defineProperty; 8 | DP(Object.prototype, '__defineSetter__', { 9 | value: function (n, f) { 10 | DP(this, n, { enumerable: true, configurable: true, set: f }); 11 | }, writable: true, enumerable: false, configurable: true 12 | }); 13 | } 14 | })(); 15 | -------------------------------------------------------------------------------- /deps/duktape/src-input/SpecialCasing-8bit.txt: -------------------------------------------------------------------------------- 1 | 00DF; 00DF; 0053 0073; 0053 0053; # LATIN SMALL LETTER SHARP S 2 | -------------------------------------------------------------------------------- /deps/duktape/src-input/duk_api_random.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Random numbers 3 | */ 4 | 5 | #include "duk_internal.h" 6 | 7 | DUK_EXTERNAL duk_double_t duk_random(duk_hthread *thr) { 8 | return (duk_double_t) DUK_UTIL_GET_RANDOM_DOUBLE(thr); 9 | } 10 | -------------------------------------------------------------------------------- /deps/duktape/src-input/duk_bi_thrower.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Type error thrower, E5 Section 13.2.3. 3 | */ 4 | 5 | #include "duk_internal.h" 6 | 7 | DUK_INTERNAL duk_ret_t duk_bi_type_error_thrower(duk_hthread *thr) { 8 | DUK_DCERROR_TYPE_INVALID_ARGS(thr); 9 | } 10 | -------------------------------------------------------------------------------- /deps/duktape/src-input/duk_hbuffer_assert.c: -------------------------------------------------------------------------------- 1 | /* 2 | * duk_hbuffer assertion helpers 3 | */ 4 | 5 | #include "duk_internal.h" 6 | 7 | #if defined(DUK_USE_ASSERTIONS) 8 | 9 | DUK_INTERNAL void duk_hbuffer_assert_valid(duk_hbuffer *h) { 10 | DUK_ASSERT(h != NULL); 11 | } 12 | 13 | #endif /* DUK_USE_ASSERTIONS */ 14 | -------------------------------------------------------------------------------- /deps/duktape/src-input/duk_hstring_assert.c: -------------------------------------------------------------------------------- 1 | /* 2 | * duk_hstring assertion helpers. 3 | */ 4 | 5 | #include "duk_internal.h" 6 | 7 | #if defined(DUK_USE_ASSERTIONS) 8 | 9 | DUK_INTERNAL void duk_hstring_assert_valid(duk_hstring *h) { 10 | DUK_ASSERT(h != NULL); 11 | } 12 | 13 | #endif /* DUK_USE_ASSERTIONS */ 14 | -------------------------------------------------------------------------------- /deps/duktape/src-separate/duk_api_random.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Random numbers 3 | */ 4 | 5 | #include "duk_internal.h" 6 | 7 | DUK_EXTERNAL duk_double_t duk_random(duk_hthread *thr) { 8 | return (duk_double_t) DUK_UTIL_GET_RANDOM_DOUBLE(thr); 9 | } 10 | -------------------------------------------------------------------------------- /deps/duktape/src-separate/duk_bi_thrower.c: -------------------------------------------------------------------------------- 1 | /* 2 | * Type error thrower, E5 Section 13.2.3. 3 | */ 4 | 5 | #include "duk_internal.h" 6 | 7 | DUK_INTERNAL duk_ret_t duk_bi_type_error_thrower(duk_hthread *thr) { 8 | DUK_DCERROR_TYPE_INVALID_ARGS(thr); 9 | } 10 | -------------------------------------------------------------------------------- /deps/duktape/src-separate/duk_hbuffer_assert.c: -------------------------------------------------------------------------------- 1 | /* 2 | * duk_hbuffer assertion helpers 3 | */ 4 | 5 | #include "duk_internal.h" 6 | 7 | #if defined(DUK_USE_ASSERTIONS) 8 | 9 | DUK_INTERNAL void duk_hbuffer_assert_valid(duk_hbuffer *h) { 10 | DUK_ASSERT(h != NULL); 11 | } 12 | 13 | #endif /* DUK_USE_ASSERTIONS */ 14 | -------------------------------------------------------------------------------- /deps/duktape/src-separate/duk_hstring_assert.c: -------------------------------------------------------------------------------- 1 | /* 2 | * duk_hstring assertion helpers. 3 | */ 4 | 5 | #include "duk_internal.h" 6 | 7 | #if defined(DUK_USE_ASSERTIONS) 8 | 9 | DUK_INTERNAL void duk_hstring_assert_valid(duk_hstring *h) { 10 | DUK_ASSERT(h != NULL); 11 | } 12 | 13 | #endif /* DUK_USE_ASSERTIONS */ 14 | -------------------------------------------------------------------------------- /deps/duktape/tools/json2yaml.py: -------------------------------------------------------------------------------- 1 | import os, sys, json, yaml 2 | 3 | if __name__ == '__main__': 4 | # Use safe_dump() instead of dump() to avoid tags like "!!python/unicode" 5 | print(yaml.safe_dump(json.load(sys.stdin), default_flow_style=False)) 6 | -------------------------------------------------------------------------------- /deps/duktape/tools/yaml2json.py: -------------------------------------------------------------------------------- 1 | import os, sys, json, yaml 2 | 3 | if __name__ == '__main__': 4 | print(json.dumps(yaml.load(sys.stdin))) 5 | -------------------------------------------------------------------------------- /deps/libuv/.gitattributes: -------------------------------------------------------------------------------- 1 | test/fixtures/lorem_ipsum.txt text eol=lf 2 | -------------------------------------------------------------------------------- /deps/libuv/.github/ISSUE_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | 12 | * **Version**: 13 | * **Platform**: 14 | -------------------------------------------------------------------------------- /deps/libuv/.github/workflows/sanitizer.yml: -------------------------------------------------------------------------------- 1 | name: Sanitizer checks 2 | 3 | on: [push, pull_request] 4 | 5 | jobs: 6 | asan: 7 | runs-on: ubuntu-latest 8 | steps: 9 | - uses: actions/checkout@v2 10 | - name: Envinfo 11 | run: npx envinfo 12 | - name: ASAN 13 | run: | 14 | mkdir build 15 | cd build && cmake .. -DBUILD_TESTING=ON -DASAN=ON -DCMAKE_BUILD_TYPE=Debug 16 | cmake --build . && ./uv_run_tests_a 17 | 18 | -------------------------------------------------------------------------------- /deps/libuv/docs/code/cgi/tick.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int i; 6 | for (i = 0; i < 10; i++) { 7 | printf("tick\n"); 8 | fflush(stdout); 9 | sleep(1); 10 | } 11 | printf("BOOM!\n"); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /deps/libuv/docs/code/helloworld/main.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int main() { 6 | uv_loop_t *loop = malloc(sizeof(uv_loop_t)); 7 | uv_loop_init(loop); 8 | 9 | printf("Now quitting.\n"); 10 | uv_run(loop, UV_RUN_DEFAULT); 11 | 12 | uv_loop_close(loop); 13 | free(loop); 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /deps/libuv/docs/code/plugin/hello.c: -------------------------------------------------------------------------------- 1 | #include "plugin.h" 2 | 3 | void initialize() { 4 | mfp_register("Hello World!"); 5 | } 6 | -------------------------------------------------------------------------------- /deps/libuv/docs/code/plugin/plugin.h: -------------------------------------------------------------------------------- 1 | #ifndef UVBOOK_PLUGIN_SYSTEM 2 | #define UVBOOK_PLUGIN_SYSTEM 3 | 4 | // Plugin authors should use this to register their plugins with mfp. 5 | void mfp_register(const char *name); 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /deps/libuv/docs/code/proc-streams/test.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() 4 | { 5 | fprintf(stderr, "This is stderr\n"); 6 | printf("This is stdout\n"); 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /deps/libuv/docs/src/api.rst: -------------------------------------------------------------------------------- 1 | .. _api: 2 | 3 | API documentation 4 | ================= 5 | 6 | .. toctree:: 7 | :maxdepth: 1 8 | 9 | errors 10 | version 11 | loop 12 | handle 13 | request 14 | timer 15 | prepare 16 | check 17 | idle 18 | async 19 | poll 20 | signal 21 | process 22 | stream 23 | tcp 24 | pipe 25 | tty 26 | udp 27 | fs_event 28 | fs_poll 29 | fs 30 | threadpool 31 | dns 32 | dll 33 | threading 34 | misc 35 | metrics 36 | 37 | -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/architecture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/architecture.png -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/diagrams.key/Data/st0-311.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/diagrams.key/Data/st0-311.jpg -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/diagrams.key/Data/st1-475.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/diagrams.key/Data/st1-475.jpg -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/diagrams.key/Index.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/diagrams.key/Index.zip -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/diagrams.key/Metadata/BuildVersionHistory.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Template: White (2014-02-28 09:41) 6 | M6.2.2-1878-1 7 | 8 | 9 | -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/diagrams.key/Metadata/DocumentIdentifier: -------------------------------------------------------------------------------- 1 | F69E9CD9-EEF1-4223-9DA4-A1EA7FE112BA -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/diagrams.key/Metadata/Properties.plist: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/diagrams.key/Metadata/Properties.plist -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/diagrams.key/preview-micro.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/diagrams.key/preview-micro.jpg -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/diagrams.key/preview-web.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/diagrams.key/preview-web.jpg -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/diagrams.key/preview.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/diagrams.key/preview.jpg -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/favicon.ico -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/logo.png -------------------------------------------------------------------------------- /deps/libuv/docs/src/static/loop_iteration.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/docs/src/static/loop_iteration.png -------------------------------------------------------------------------------- /deps/libuv/docs/src/upgrading.rst: -------------------------------------------------------------------------------- 1 | .. _upgrading: 2 | 3 | Upgrading 4 | ========= 5 | 6 | Migration guides for different libuv versions, starting with 1.0. 7 | 8 | .. toctree:: 9 | :maxdepth: 1 10 | 11 | migration_010_100 12 | -------------------------------------------------------------------------------- /deps/libuv/img/banner.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/img/banner.png -------------------------------------------------------------------------------- /deps/libuv/libuv-static.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@prefix@ 2 | exec_prefix=${prefix} 3 | libdir=@libdir@ 4 | includedir=@includedir@ 5 | 6 | Name: libuv-static 7 | Version: @PACKAGE_VERSION@ 8 | Description: multi-platform support library with a focus on asynchronous I/O. 9 | URL: http://libuv.org/ 10 | 11 | Libs: -L${libdir} -luv_a @LIBS@ 12 | Cflags: -I${includedir} 13 | -------------------------------------------------------------------------------- /deps/libuv/libuv.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@prefix@ 2 | exec_prefix=${prefix} 3 | libdir=@libdir@ 4 | includedir=@includedir@ 5 | 6 | Name: libuv 7 | Version: @PACKAGE_VERSION@ 8 | Description: multi-platform support library with a focus on asynchronous I/O. 9 | URL: http://libuv.org/ 10 | 11 | Libs: -L${libdir} -luv @LIBS@ 12 | Cflags: -I${includedir} 13 | -------------------------------------------------------------------------------- /deps/libuv/m4/.gitignore: -------------------------------------------------------------------------------- 1 | # Ignore libtoolize-generated files. 2 | *.m4 3 | !as_case.m4 4 | !ax_pthread.m4 5 | !libuv-check-flags.m4 6 | -------------------------------------------------------------------------------- /deps/libuv/test/fixtures/empty_file: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/indutny/dukhttp/4ae658c0841d32fe71ad653ee1399bd98d546b41/deps/libuv/test/fixtures/empty_file -------------------------------------------------------------------------------- /deps/libuv/test/fixtures/load_error.node: -------------------------------------------------------------------------------- 1 | foobar 2 | -------------------------------------------------------------------------------- /deps/libuv/test/fixtures/lorem_ipsum.txt: -------------------------------------------------------------------------------- 1 | Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. 2 | -------------------------------------------------------------------------------- /deps/libuv/uv_win_longpath.manifest: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | true 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /deps/llhttp/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.4) 2 | project(llhttp LANGUAGES C) 3 | 4 | add_library(llhttp src/api.c src/http.c src/llhttp.c) 5 | 6 | target_include_directories(llhttp 7 | PUBLIC 8 | ${PROJECT_SOURCE_DIR}/include) 9 | -------------------------------------------------------------------------------- /deps/llhttp/llhttp.gyp: -------------------------------------------------------------------------------- 1 | { 2 | 'targets': [ 3 | { 4 | 'target_name': 'llhttp', 5 | 'type': 'static_library', 6 | 'include_dirs': [ '.', 'include' ], 7 | 'direct_dependent_settings': { 8 | 'include_dirs': [ 'include' ], 9 | }, 10 | 'sources': [ 'src/llhttp.c', 'src/api.c', 'src/http.c' ], 11 | }, 12 | ] 13 | } 14 | -------------------------------------------------------------------------------- /examples/handler.js: -------------------------------------------------------------------------------- 1 | (function handler(headers, url, method) { 2 | if (method !== 'GET') { 3 | return { code: 405, body: 'Invalid method' }; 4 | } 5 | 6 | if (url === '/') { 7 | return { code: 200, body: 'Main page' }; 8 | } 9 | 10 | if (url === '/about') { 11 | return { code: 200, body: 'About this project' }; 12 | } 13 | 14 | return { 15 | code: 404, 16 | body: 'Not found', 17 | }; 18 | }) 19 | --------------------------------------------------------------------------------